Your Search Results

    ccache

    ccache is a compiler cache for C and C++. It does what its function implies: caches the results of compilations. The net result: builds are faster!

    Installing

    ccache is typically available in your operating system's package manager of choice.

    On Mac:

    $ brew install ccache 

    On Ubuntu:

    $ sudo apt-get install ccache
    

    Configuring ccache

    By default, ccache will put its cache in ~/.ccache. You can verify this by running:

     $ ccache -s

    That prints out the location of the current cache with some statistics.

    You can modify the location of the cache via environment variables such as CCACHE_DIR. For more, see the man page: $ man ccache.

    Like most anything that is I/O bound, ccache will benefit from having its cache on a fast I/O device, like an SSD. If you can, configure your cache to run off the fastest device you can. If you are using magnetic storage, put the cache on a separate spindle from the source tree you are building.

    For example,

    $ export CCACHE_DIR=/Volumes/Scratch/ccache 
    

    The default cache size is 1GB. A typical mozilla-central build of Firefox will fully saturate a cache of this size, evicting entries and thus lowering cache hit rate. You'll want an 8GB cache to get a good hit rate (For FirefoxOS 10-20Gb is a better size (min 10Gb)).  You can modify the cache size as follows:

     $ ccache --max-size 8G
    

    Enabling compression can greatly increase the number of files held in the cache, to enable it define the CCACHE_COMPRESS environment variable. To make this setting permanent you may want to add the following command to your .bashrc file:

     $ export CCACHE_COMPRESS=""
    

    Configuring Mozilla Builds

    To configure Mozilla builds to use ccache, you'll need to configure some make and configure options. In your .mozconfig, add the following:

     ac_add_options --with-ccache=/usr/local/bin/ccache
    

    Be sure to specify the appropriate path to ccache on your system!

    Now, run a build and verify the cache is being utilized:

    $ ccache -s
    
    cache directory /home/gps/.ccache
    cache hit (direct)                     0
    cache hit (preprocessed)               0
    cache miss                             0
    files in cache                         0
    cache size                             0 Kbytes
    max cache size                       2.0 Gbytes
    
    $ make -f client.mk build
    
    # in another shell, after the build has churned for a while:
    $ ccache -s
    
    cache directory                     /home/gps/.ccache
    cache hit (direct)                     2
    cache hit (preprocessed)               7
    cache miss                          2044
    called for link                       27
    preprocessor error                     1
    unsupported source language            1
    autoconf compile/link                 19
    unsupported compiler option            4
    files in cache                      6226
    cache size                         659.0 Mbytes
    max cache size                       2.0 Gbytes
    

    Clang and ccache

    When building with Clang under ccache, you might notice the absence of color diagnostics. This happens because Clang thinks it's not printing to the console. To workaround this, tweak your .mozconfig so the relevant lines have the following parameters:

    CC="clang -fcolor-diagnostics"
    CXX="clang++ -fcolor-diagnostics"
    

    Sample Performance Impact

    The following lists sample impact of ccache on build times. The first build should be ran with ccache enabled, but an empty cache. The second build should be executed after a distclean.

    System Description

    Build Type

    First Build (Empty Cache)

    Second Build (Populated Cache)

    Change

    • Core i7-2600K

    • 64 bit Linux VM inside Windows 7

    • 2.5GB RAM

    • Source and cache on same spindle

    • browser application

    • -j8

    • --enable-tests

    • -O2

    • mozilla-central on 2011-08-11

    • 17:30 wall

    • 37:04 user

    • 4:28 sys

    • 7:12 wall

    • 2:51 user

    • 1:04 sys

    • -10:28 wall (1.45x faster)

    • -34:13 user (12x faster!)

    • -3:24 sys (3.19x faster)

    Tricks and Caveats

    • Builds with make and PyMake generally don't produce the same compilation environment. Therefore, you'll get cache misses due to the heuristics used by ccache. So, if you build with both tools, you'll effectively have two copies of everything in your cache. You may need to increase your cache size to handle the extra files.

    Document Tags and Contributors

    Last updated by: dhylands@mozilla.com,