At some point most of you have encountered “the” parallel build problem: a build that works just fine when run serially, but breaks sometimes when run in parallel. You may have read my blog about how ElectricAccelerator automatically solves the classic parallel build problem. Recently I ran into the opposite problem in a customer’s build: a build that “works” when run in parallel, but breaks when run serially! If you’re lucky, this build defect will just cause occasional build failures. If you’re unlucky, it will silently corrupt your build output at random. With traditional GNU make this nasty bug is a nightmare to track down — if you even know that its present!
In contrast, the unique features in ElectricAccelerator make it trivial to find the defect — some might even say it’s fun (well, if you’re like me and you enjoy using powerful tools to do sophisticated analysis without breaking a sweat!). Read on to see how ElectricAccelerator makes it easy to diagnose and fix bugs in your build.
The inverted parallel build bug
Let’s start with a concrete example. Here’s a simple Makefile which (appears to) work when run in parallel, but which consistently fails serially:
Assuming that output does not exist, executing this makefile serially will always produce an error:
But if you execute this makefile in parallel, it appears to work!:
If we visualize the execution of these commands it’s easy to see why the parallel build seems to work:
At the beginning of the build, both reader and writer are started, more-or-less at the same time, because we told gmake to run two jobs at a time. reader has two commands, which are executed serially according to the semantics of make. While the sleep 2 is executing, the echo command in writer runs and completes. When the cat command in reader starts, it succeeds because output is ready-to-go.
Parallel execution is no guarantee
Some people will look at that explanation and think “Got it — always run this thing in parallel and we’re good!” Of course, you can’t really be 100% sure that everybody will remember to run the makefile in parallel. But even if you could, there’s a flaw in that reasoning: basically, your build has a race condition, and there’s no guarantee that you’ll “win” the race every time. For example, if your build server is heavily loaded, the sequence of events might look like this instead:
Here, writer doesn’t get started until after the sleep command has finished — too late to save the cat command from failure.
Build failure is not the worst outcome
Before we move on to finding and fixing problems like this, let’s take a quick look at one more failure mode: incremental builds. In particular, check out what happens if output exists before the build starts, but with incorrect content (for example, stale data from an earlier build):
That’s right — the build “succeeded”, because it produced no error messages and exited with a zero exit code. And yet, it produced completely bogus output. Ouch!
Somebody save me!
If you’re using ordinary GNU make, you’re in for a world of hurt with a problem like this. First, the only way to consistently reproduce the problem is to run the entire build serially — of course that probably takes a long time, or you wouldn’t have been using parallel builds in the first place. Second, there are no diagnostics built into gmake that could help you identify which job produces output. One option is to use strace to monitor filesystem accesses, but that will generate a mountain of data in a not-very-usable format. Plus, it imposes a substantial performance penalty — on top of the hit you’d already take for running the build serially. Yuck!
If you’re using Electric Make, this problem is embarrassingly easy to solve thanks to emake’s core features:
- Consistent results: emake mimics serial execution with gmake, so you’ll always get a consistent result with this build. That means it will fail, the same way, every time, which means you’ll discover the problem immediately after it is introduced, not months or years later after it has become nearly impossible to tell which Makefile change introduced the defect.
- Parallel speed: emake’s results match those of a serial gmake build, but its performance is more like that of a parallel gmake build — better, in most cases.
- Annotated build logs: emake can generate an XML-enhanced version of the build output log which contains a record of every file accessed by every job in the build. This annotation file can easily be mined to identify pairs of jobs where the reader preceeds the writer.
You can use any general purpose XML parsing library to read annotation files, but it’s easy to use annolib, the high-performance annotation processing library we wrote to facilitate this kind of analysis. Since annolib is built into ElectricInsight, the easiest way to use it is to write the analysis as a custom Insight report. All you need to do is iterate through the files referenced in the build, looking for read operations (or, in this case, failed lookups) preceeding a write operation. Here’s the code:
global anno
set instances [list]
# Iterate over the files referenced in the build...
foreach filename [$anno files] {
set readers [list]
# Iterate over the operations performed on the file...
foreach tuple [$anno file operations $filename] {
foreach {job op dummy} $tuple { break }
if { $op == "read" || $op == "failedlookup" } {
# If this is a read operation, note the job that did the read.
lappend readers $job
} elseif {$op == "create" || $op == "modify" || $op == "truncate"} {
# If this is a write operation but earlier jobs already read
# the file, we've found a read-before-write instance.
if { [llength $readers] } {
lappend instances [list $readers $job $filename]
}
# After we see a write on this file we can move on to the next.
break
}
}
}
# For each instance, print the filename, the writer, and each reader.
set result ""
foreach instance $instances {
foreach {readers writer filename} $instance { break }
set writerName [$anno job name $writer]
set writerFile [$anno job makefile $writer]
set writerLine [$anno job line $writer]
append result "FILENAME:\n $filename\n"
append result "WRITER :\n $writerName ($writerFile:$writerLine)\n"
append result "READERS :\n"
foreach reader $readers {
set readerName [$anno job name $reader]
set readerFile [$anno job makefile $reader]
set readerLine [$anno job line $reader]
append result " $readerName ($readerFile:$readerLine)\n"
}
}
With a bit of additional boilerplate you can run this report from the command-line with Insight 4.0 (currently in limited beta). A couple notes on usage: you should instruct emake to generate lookup-level annotation, by adding –emake-annodetail=lookup to your invocation. And, you should run the build with the -k (keep-going) option — otherwise, the error in reader will prevent writer from running, and emake will not record filesystem usage for it. Once you have a suitable annotation file, here’s how the report looks for this build:
Voila! We’ve pinpointed the problem with barely 50 lines of code (including comments!). You can even see a solution: add writer as a prerequisite of reader, on line 3 of Makefile.
Show me what you can do with ElectricAccelerator
As you’ve seen, ElectricAccelerator makes it easy to identify and correct build problems that would otherwise be nearly impossible to root out. Hopefully you also see that this is just the tip of the iceberg — with consistent fast builds and the treasure trove of data available in annotation files, what other analysis could you do? To get started, you can download a free trial of ElectricAccelerator Developer Edition and check out the reports in ElectricInsight. You can also download the Read Before Write report for ElectricInsight from my GitHub repo. If you come up with something cool, tell me about it in the comments!
eric melski's blog.melski.net 