Real World Mozilla Incremental Build Lab

From CDOT Wiki
Jump to: navigation, search

Real World Mozilla > Real World Mozilla Day 3 > Incremental Build Lab


This lab is designed to give you first-hand experience creating and applying patches, and doing incremental builds of your source tree. The concepts introduced in this lab will help you understand how to make small changes to your tree, share those with others, or use other people's changes.


Because the source tree is so large, developers use patches as the basic unit of work for passing code back and forth. A patch is a text file that contains information necessary to add or remove lines from a source tree. Patches are created using the cvs diff command.

NOTE: All instructions below assume the use of an objdir. Replace all uses of objdir with your object directory path.

Making a change and doing incremental builds

  • Make a small change to a file in your tree, for example, a .cpp file in mozilla/netwerk/protocol/http/src. Here is a possible change:
#include <stdio.h>
...inside a function somewhere...
/* DEBUG_<username> is defined at build time, and Faculty is the username in the lab */
#ifdef DEBUG_Faculty
printf("Hello World!\n");
...inside a function somewhere...
  • Make sure your change compiles. You need to rebuild your tree in order to test using one of the following methods:
$ cd mozilla
$ make -f build

or, to make things go faster, move to the parallel location in your objdir and run make there

$ cd mozilla/objdir/netwerk/protocol/http/src
$ make

Create a patch

  • Now create a patch containing the changes you just made using the so called 'unified' format (-u), with 8 lines of context. By default the diff is printed to stdout, so you should redirect it to a file. Typically patches are created from the mozilla/ root directory, so that they can be easily applied later on (i.e., people don't have to figure out where to apply the patch, and can just use their tree's root directory):
$ cd mozilla
$ cvs diff -u8p . > patch.txt
  • Open patch.txt in a text editor and notice the changes you made are prefixed with + signs. Any code you deleted will be prefixed with a - sign.

Apply a patch

  • Trade patches with someone else in the class (use and IRC), and take turns trying to apply their patch to your tree:
$ cd mozilla
$ patch -p0 < patch.txt

(unless you are using hg checkout/patches then you want to look here for updated instructions)

  • Here -p0 means strip 0 leading directories from each filename in the patch. We do this because we are in the same location (i.e., ./) as the person who created the patch. If the directories were mis-aligned, we would have to strip leading directories using -p1, -p2, etc.
  • You can use the --dry-run option to test and see what would happen if you did apply the patch. Some people like to call patch with the -s or --silent or --quiet option (all do the same thing). This will suppress all output except error messages, and can make it easier to see which parts don't work.

Backing-out a patch

  • Now try backing-out this same patch. To do this you can call patch with the -R or --reverse option to tell it to swap the old and new files, basically reversing the patch.
$ cd mozilla
$ patch -R -p0 < patch.txt
  • Check to make sure the changes in patch.txt are gone from the file.

Applying a real patch

Mozilla's Mike Shaver wrote about an idea to add instrumentation to Firefox in order to determine how much time is spent away from the main event loop. His blog post included prototype code in the form of a patch.

Download Mike's patch. Save the file (do not copy-paste it) to your mozilla/ directory.

  • Apply the patch, using what you learned above. Remember the --dry-run option and to examine the paths of files in the patch.
  • Rebuild the necessary parts of your tree:
$ cd mozilla/objdir
$ cd xpcom
$ make
  • Run your browser and watch for messages in stderr

Life-cycle of a patch in review

When someone submits a patch, it goes through extensive review. It is rare that a patch is accepted "as is." Usually it will go through many iterations, with comments being made at each step.

Read the comments in the following bug to see an example of this process, and watch the evolution of the patch in terms of stylistic changes to the code, fixes, optimizations, etc: