Updated xorg-server and mesa live-git packages

Today I reworked the mesa and xorg-server ebuilds to do things the cool way with the latest git sources. Mesa added an autoconf build, thanks to Dan Nicholson, which makes the ebuild a lot simpler and less error-prone by being more standardized. There’s no XCB support yet–if nobody else adds it, I’ll probably do it eventually. It’s just autoconf, no automake, so the installation side of the ebuild stayed pretty complex. There’s a few strange things going on with what headers mesa installs that I haven’t looked into besides just deleting them.

Also, these updates incorporate the first major step to removing the extra copy of the mesa source code used to build xorg-server. The GLcore module is now built within mesa instead of xorg-server, thanks to George Sapountzis. This created a circular dependency between xorg-server and mesa, so I made a new ebuild called mesa-glcore. Unfortunately this means that libmesa.a still gets built twice. The other half of getting the mesa source out of the xorg-server build is libglx, and I’m hoping someone does it soon (hint, hint!).

This work is all available in the Gentoo x11 overlay, which you can add with the simple command `layman -a x11`.

Mix a tight package GUI with Gentoo for Summer of Code

PackageKit is this amazing idea of having a tool for managing packages that works identically on every distribution. It’s got both a GUI and a command-line tool, called pkcon. Check out some screenshots. To reach that goal, it has to actually work on every distro.

Wouldn’t it be great if PackageKit worked on Gentoo? You could make that happen! Three major package managers work with Gentoo: portage, paludis, and pkgcore. Working on this as a Summer of Code project means you’d write a PackageKit backend for one of these package managers, in the process learning the API of each and working with PackageKit founder Richard Hughes, me, the developers of one of the package managers, and the broader Gentoo and PackageKit communities.

Three potential applicants have already talked with me about this, so space is limited. You can reach me by email or on IRC (irc.freenode.net/#packagekit as dberkholz) if you’d like to talk about your ideas.

Summer of Code applications are only open until April 1, 0000 UTC, so apply now!

Redux: Gentoo’s top 3 issues

People were so busy complaining about my pie chart that most of them apparently didn’t have a chance to think about the meaning of the actual data. To try helping people look at the information rather than its presentation, here’s a bar chart of the same information:

I don’t recommend looking at it because you may go blind, but I’ve made available the (extremely ugly) script that created this.

What are the top 3 issues facing Gentoo?

I ran a quick, informal poll on the internal Gentoo developers’ list last week, and tonight I began analyzing the results. 50 developers responded to my 9-question survey, and I’m going to post the results of 1 question at a time.

First question: What are the top 3 issues facing Gentoo?

Pie chart

Technical issues are way down on the list. Developers’ top 5 issues are manpower, publicity, goals, developer friction, and leadership. It’s good to see that we’ve been addressing at least a couple of them with the newly energized public relations project and work on the Code of Conduct. Other issues that have been ongoing for quite a while now are the lack of distro-wide vision and goals. The Council could provide those by increased activity and taking stronger stands in particular directions, and that’s part of the reason I did this survey—to figure out which directions our developers care about. I think part of the problem is that nobody sits around pondering directions and ideas. Everybody’s busy working in their own little areas and not thinking about the big picture. Manpower, or lack of it, is another issue I’m indirectly addressing in my push for greatness, which I’m going to post more about at some point (I promise!).

To create this chart, I used Google’s excellent chart API. The neat part about the API is that it’s simply a URL, so you can construct it with any language. I used a shell script since I was already fiddling around with awk. Any answer with less than 4 respondants was grouped into Other to make the rest of the chart readable.

New GCC hotness

I’ve been talking with Lance lately about setting up a good development machine, and GCC 4.3 (still unreleased) came up so I checked out its changes. Here’s a few I found particularly cool:

  • A new forward propagation pass on RTL was added. The new pass replaces several slower transformations, resulting in compile-time improvements as well as better code generation in some cases.
  • A new command-line switch -frecord-gcc-switches has been added to GCC, although it is only enabled for some targets. The switch causes the command line that was used to invoke the compiler to be recorded into the object file that is being created. The exact format of this recording is target and binary file format dependent, but it usually takes the form of a note section containing ASCII text. The switch is related to the -fverbose-asm switch, but that one only records the information in the assembler output file as comments, so the information never reaches the object file.
  • A new internal representation for GIMPLE statements has been contributed, resulting in compile-time memory savings.
  • A new command-line option -fdirectives-only has been added. It enables a special preprocessing mode which improves the performance of applications like distcc and ccache.
  • Experimental support for the upcoming ISO C++ standard, C++0x
  • Fortran: The -fexternal-blas option has been added, which generates calls to BLAS routines for intrinsic matrix operations such as matmul rather than using the built-in algorithms.
  • Fortran: Support to give a backtrace (compiler flag -fbacktrace or environment variable GFORTRAN_ERROR_BACKTRACE; on glibc systems only) or a core dump (-fdump-core, GFORTRAN_ERROR_DUMPCORE) when a run-time error occurred.
  • Java: libgcj now supports all 1.5 language features which require runtime support: foreach, enum, annotations, generics, and auto-boxing.
  • x86/amd64: Tuning for Intel Core 2 processors is available via -mtune=core2 and -march=core2.
  • x86/amd64: Code generation of block move (memcpy) and block set (memset) was rewritten. GCC can now pick the best algorithm (loop, unrolled loop, instruction with rep prefix or a library call) based on the size of the block being copied and the CPU being optimized for. A new option -minline-stringops-dynamically has been added. With this option string operations of unknown size are expanded such that small blocks are copied by in-line code, while for large blocks a library call is used. This results in faster code than -minline-all-stringops when the library implementation is capable of using cache hierarchy hints.
  • x86/amd64: Support for SSSE3 built-in functions and code generation are available via -mssse3.
  • x86/amd64: Both SSE4.1 and SSE4.2 support can be enabled via -msse4.
  • x86/amd64: GCC can now utilize the ACML library for vectorizing calls to a set of C99 functions on x86_64 if -mveclibabi=acml is specified and you link to an ACML ABI compatible library.
  • MIPS: libffi and libjava now support all three GNU/Linux ABIs: o32, n32 and n64. Every GNU/Linux configuration now builds these libraries by default.
  • The configure options –with-pkgversion and –with-bugurl have been added. These allow distributors of GCC to include a distributor-specific string in manuals and –version output and to specify the URL for reporting bugs in their versions of GCC.

I’m already using GCC 4.2, but I hadn’t really looked into its changes either until now:

  • OpenMP is now supported for the C, C++ and Fortran compilers.
  • A new command-line option -Waddress has been added to warn about suspicious uses of memory addresses as, for example, using the address of a function in a conditional expression, and comparisons against the memory address of a string literal. This warning is enabled by -Wall.
  • C++: -Wextra will produce warnings for if statements with a semicolon as the only body
  • C++/libstdc++: Enabled library-wide visibility control, allowing -fvisibility to be used.
  • x86/amd64: -mtune=generic can now be used to generate code running well on common x86 chips. This includes AMD Athlon, AMD Opteron, Intel Pentium-M, Intel Pentium 4 and Intel Core 2.
  • x86/amd64: -mtune=native and -march=native will produce code optimized for the host architecture as detected using the cpuid instruction.

Who made Gentoo Linux, and when? A commit analysis

LWN just published my story of this name as premium content. I ran a number of analyses on Gentoo’s CVS commit history, kindly provided by Robin Johnson, to look at what happened to our developers and our commits over time. If you want to know the results now (rather than waiting until the content becomes free), subscribe to LWN—the best Linux and open-source software news.

Improving quality in Gentoo

I recently posted about making Gentoo a better tool. A requirement for being a good tool is being a tool that doesn’t break—thus, we need to improve our quality to a more reliable level. I’m going to mention a few ideas to start this discussion, which I hope the rest of our community will participate in.

First, we essentially have no code review. About the only time any code in Gentoo is reviewed is before and during a developer’s training, with a notable exception being the requirement to post eclasses to the gentoo-dev list. Increasing our code review ought to result in an increase in quality, in ability to justify code in words, and in a stronger community of contributors.

How do we increase code review? One idea is to require reviewer approval prior to committing, but this isn’t the best answer for Gentoo. We’ve always been a pretty open community. Developers aren’t prohibited by ACL from committing anywhere in our ebuild repository, so I don’t think they would accept additional requirements that increased the burden of contributing.

Instead, let’s create a gentoo-commits mailing list or RSS feed(s), with full diffs. We should use this tool in many different ways.

  • Each team should use it internally to review all commits to its packages.
  • Mentors should continue to follow their mentees’ commits well after they’re granted commit access (6 months minimum, and I recommend forever).
  • Mentees should also review their mentors’ commits, first to learn and later to review.
  • Every developer should have at least one reviewer and review at least one other developer. This should be formal and documented to ensure it’s happening.

These uses will require that the commit diffs be easily filterable by both committer and files affected. RSS feeds could be made available based on developer or herd, and e-mail lists could contain the information in e-mail subjects or headers.

Second, we should improve our unit testing, where the units are individual packages. This can be both automated and performed by developers and arch testers. Although a number of packages have a useful, working test suite, most lack one. For these packages, we should attempt to provide something automatable in src_test() even when a test suite is absent. Failing that, we should print out a checklist in src_test() of tests to perform before stabilizing a package. There should never be an empty src_test().

Another package-level testing approach is to create solid, automated tinderboxes. This remains unrealistic for our entire database of 10,000+ packages, but we should at least get this going for our “system” set and perhaps for some of the most common sets of packages for servers and desktops. Exactly how to set this up remains a question, since there’s a lot of tinderbox code floating around. Bonsaikitten has some almost-working code based on swegener’s work; Catalyst has some tinderboxing capability; or we could look into using Mozilla’s tinderbox.

Third, we should improve our integration testing, on the entire repository level. Our main source of testing here will be our users, because they have infinitely more combinations of build options and hardware than we can reproduce on Gentoo infrastructure. But how can we take advantage of this testing to improve our quality? By creating an additional, time-lagged set of rsync mirrors with additional QA checks, we could allow users who want to test the latest and greatest software to help those who want stable and solid software.

We already have keywords for ~arch and arch, but they’re still too mixed. A problem in ~arch ebuilds can break the entire tree for all users. They really need a stronger separation. Perhaps the separate repositories should be ~arch versus stable. But another way to do it is to add a delay to the second set of repos, anywhere from 24 hours to a week. This delay allows us time to encounter major problems in the fast-sync repos, fix them, and carry the fixes over to the slow-sync repo. But we’ll need a way to make this really easy to do. It feels like branching with periodic merges, along with cherry picks of major bugfixes, is the right way to do this. Unfortunately, CVS sucks at this. We may need to migrate to a more capable version-control system before this option becomes realistic. In addition to the user testing, we could add a tinderbox into the slow-sync repos to require that they build with the most common configurations.

To sum up, I want to increase code review, unit testing, and integration testing. These three things will strengthen Gentoo’s quality, reputation, and community.