How to Use CCache with CMake?

Question

I would like to do the following: If CCache is present in PATH, use "ccache g++" for compilation, else use g++. I tried writing a small my-cmake script containing

    CC="ccache gcc" CXX="ccache g++" cmake $*

but it does not seem to work (running make still does not use ccache; I checked this using CMAKE_VERBOSE_MAKEFILE on).

Update:

As per this link I tried changing my script to

     cmake -D CMAKE_CXX_COMPILER="ccache" -D CMAKE_CXX_COMPILER_ARG1="g++" -D CMAKE_C_COMPILER="ccache" -D CMAKE_C_COMPILER_ARG1="gcc" $*

but cmake bails out complaining that a test failed on using the compiler ccache (which can be expected).

Why don't you just symlink gcc to ccache? And if you're distributing this, I'd think that the user himself would have done the symlink if he had ccache installed and wanted it to be used.. — int3, Nov 29, 2009 at 14:46
@int3 Yes probably that would work (I was not aware that ccache has the compiler as an optional argument). However it would be cleaner to be more explicit. — amit kumar, Nov 29, 2009 at 15:00

Jacob · Answer 1 · 2016-06-15 07:19:31Z

154

As of CMAKE 3.4 you can do:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

answered Jun 15, 2016 at 7:19

Jacob

3,43166 gold badges2424 silver badges3333 bronze badges

2

And -DCMAKE_CXX_COMPILER_LAUNCHER=ccache. These work beautifully! I do not know why cmake insists on finding clang from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc (so the symlink trick does not work), rather than from $PATH, but your answer works anyway.
– cdunn2001
May 9, 2017 at 7:56
6

This should be the best answer. No more messing with path variable and compiler symlinks!
– ilya b.
Apr 9, 2018 at 13:59
2

I tried this, but it just gives me the error "ccache: error: Recursive invocation (the name of the ccache binary must be "ccache")". Looking at the verbose trace, it is trying to run "/usr/local/bin/ccache ccache /usr/bin/c++"...
– Chris Dodd
Feb 17, 2019 at 20:19
7

How does it interact with RULE_LAUNCH_COMPILE?
– Trass3r
May 31, 2019 at 18:25
1

@ThuongVo anyone who is familiar with cmake knows that -D is a prefix for an option passsed as a CLI parameter. So, given the context of the question, it is somewhat clear to use this when invoking cmake (on configuration that is)
– Sergey Kolesnik
Aug 16, 2022 at 7:17

Show 3 more comments

Babcool · Answer 2 · 2019-10-22 00:59:49Z

It is now possible to specify ccache as a launcher for compile commands and link commands (since cmake 2.8.0). That works for Makefile and Ninja generator. To do this, just set the following properties :

find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) # Less useful to do it for linking, see edit2
endif(CCACHE_FOUND)

It is also possible to set these properties only for specific directories or targets.

For Ninja, this is possible since version 3.4. For XCode, Craig Scott gives a workaround in his answer.

Edit : Thanks to uprego and Lekensteyn's comment, I edited the answer to check if ccache is available before using it as launcher and for which generators is it possible to use a compile launcher.

Edit2: @Emilio Cobos recommended to avoid doing that for the linking part as ccache doesn't improve linking speed and can mess with other types of cache like sccache

Many sites implicitly advice using doublequotes like in find_program(CCACHE_FOUND "ccache"), I don't know which one is more portable, my mileage did perfectly fine without the need for the doublequotes. — 1737973, Jun 16, 2015 at 11:33
It's worth noting that this currently only works for Makefile generators (as of cmake 3.3.2). See the manual page of cmake-properties. — Lekensteyn, Oct 5, 2015 at 14:34
It is worth noting that this conflicts with the CTEST_USE_LAUNCHERS setting. Those properties are set here too: github.com/Kitware/CMake/blob/master/Modules/… — purpleKarrot, May 15, 2018 at 11:52
I think you may want to change the code to this one (except, remove text from inside of endif()). The improvements are: 1. There's a configuration option to disable it, and 2. Turns out, colors disappear from GCC/Clang in Make backend when used this way. The ninja backend works around it by adding -fdiagnostics-color option, so it's advisable to do so for make backend too. — Hi-Angel, Oct 6, 2019 at 12:30
From the docs: This property is intended for internal use by ctest(1). Projects and developers should use the <LANG>_COMPILER_LAUNCHER target properties or the associated CMAKE_<LANG>_COMPILER_LAUNCHER variables instead. — Marc Dirven, Sep 1, 2022 at 14:26

Nicolás · Accepted Answer · 2009-12-23 17:21:12Z

73

I personally have /usr/lib/ccache in my $PATH. This directory contains loads of symlinks for every possible name the compiler could be called from (like gcc and gcc-4.3), all pointing to ccache.

And I didn't even create the symlinks. That directory comes pre-filled when I install ccache on Debian.

answered Dec 23, 2009 at 17:21

Nicolás

7,4133333 silver badges3535 bronze badges

11

Note that this ccache path has to be placed before the path where your real compiler is in $PATH for it to work. Something like export PATH = /usr/lib/ccache:$PATH
– Gui13
Feb 24, 2011 at 17:06
7

@Gui13: Better than updating the PATH would be to tell cmake explicitly where the gcc it should use is, e.g. cmake -DCMAKE_CXX_COMPILER=/usr/lib/ccache/bin/g++
– cib
Apr 29, 2014 at 14:36
3

After brew install ccache, I have /usr/local/Cellar/ccache/3.2.1/libexec/.
– cdunn2001
Oct 19, 2015 at 17:08

Add a comment

Craig Scott · Answer 4 · 2018-01-10 19:55:48Z

From CMake 3.1, it is possible to use ccache with the Xcode generator and Ninja is supported from CMake 3.4 onwards. Ninja will honour RULE_LAUNCH_COMPILE just like the Unix Makefiles generator (so @Babcool's answer gets you there for Ninja too), but getting ccache working for the Xcode generator takes a little more work. The following article explains the method in detail, focussing on a general implementation which works for all three CMake generators and making no assumptions about setting up ccache symlinks or the underlying compiler used (it still lets CMake decide the compiler):

https://crascit.com/2016/04/09/using-ccache-with-cmake/

The general gist of the article is as follows. The start of your CMakeLists.txt file should be set up something like this:

cmake_minimum_required(VERSION 2.8)

find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    # Support Unix Makefiles and Ninja
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
endif()

project(SomeProject)

get_property(RULE_LAUNCH_COMPILE GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
if(RULE_LAUNCH_COMPILE AND CMAKE_GENERATOR STREQUAL "Xcode")
    # Set up wrapper scripts
    configure_file(launch-c.in   launch-c)
    configure_file(launch-cxx.in launch-cxx)
    execute_process(COMMAND chmod a+rx
                            "${CMAKE_BINARY_DIR}/launch-c"
                            "${CMAKE_BINARY_DIR}/launch-cxx")

    # Set Xcode project attributes to route compilation through our scripts
    set(CMAKE_XCODE_ATTRIBUTE_CC         "${CMAKE_BINARY_DIR}/launch-c")
    set(CMAKE_XCODE_ATTRIBUTE_CXX        "${CMAKE_BINARY_DIR}/launch-cxx")
    set(CMAKE_XCODE_ATTRIBUTE_LD         "${CMAKE_BINARY_DIR}/launch-c")
    set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
endif()

The two script template files launch-c.in and launch-cxx.in look like this (they should be in the same directory as the CMakeLists.txt file):

launch-c.in:

#!/bin/sh
export CCACHE_CPP2=true
exec "${RULE_LAUNCH_COMPILE}" "${CMAKE_C_COMPILER}" "$@"

launch-cxx.in:

#!/bin/sh
export CCACHE_CPP2=true
exec "${RULE_LAUNCH_COMPILE}" "${CMAKE_CXX_COMPILER}" "$@"

The above uses RULE_LAUNCH_COMPILE alone for Unix Makefiles and Ninja, but for the Xcode generator it relies on help from CMake's CMAKE_XCODE_ATTRIBUTE_... variables support. The setting of the CC and CXX user-defined Xcode attributes to control the compiler command and LD and LDPLUSPLUS for the linker command is not, as far as I can tell, a documented feature of Xcode projects, but it does seem to work. If anyone can confirm it is officially supported by Apple, I'll update the linked article and this answer accordingly.

I also needed the set(CMAKE_XCODE_ATTRIBUTE_LD "${CMAKE_C_COMPILER}") set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_CXX_COMPILER}") from the mentioned article. — Jörn Reimerdes, Jan 10, 2018 at 6:19
Thanks for the reminder, I've updated the answer to include setting LD and LDPLUSPLUS. — Craig Scott, Jan 10, 2018 at 19:56
ccache does not support VS compilers, so you can't use it for that. There is a project called clcache which aims to provide the same functionality for VS, but I can't comment on how well it works. — Craig Scott, May 31, 2019 at 22:15

Jed · Answer 5 · 2013-03-04 14:00:22Z

I didn't like to set a symlink from g++ to ccache. And CXX="ccache g++" didn't work for me as some cmake test case wanted to have just the compiler program without attributes.

So I used a small bash script instead:

#!/bin/bash
ccache g++ "$@"

and saved it as an executable in /usr/bin/ccache-g++.

Then C configured cmake to use /usr/bin/ccache-g++ as C++ compiler. This way it passes the cmake test cases and I feel more comfortable than having symlinks that I might forget about in 2 or 3 weeks and then maybe wonder if something doesn't work...

amit kumar · Answer 6 · 2009-12-07 16:16:18Z

I verified the following works (source: this link):

        CC="gcc" CXX="g++" cmake -D CMAKE_CXX_COMPILER="ccache" -D CMAKE_CXX_COMPILER_ARG1="g++" -D CMAKE_C_COMPILER="ccache" -D CMAKE_C_COMPILER_ARG1="gcc" $*

Update: I later realized that even this does not work. Strangely it works every alternate time (the other times cmake complains).

Jürgen Weigert · Answer 7 · 2021-12-30 22:35:27Z

Let me add one important item that was not mentioned here before.

While bootstrapping a minimalistic build system from the ubuntu:18.04 docker image, I've found that order of installation makes a difference.

In my case ccache worked fine when calling gcc, but failed to catch invocations of the same compiler by the other names: cc and c++. To fully install ccache, you need to make sure all compilers are installed first, or add a call to update-ccache symlinks to be safe.

sudo /usr/sbin/update-ccache-symlinks
export PATH="/usr/lib/ccache/:$PATH"```

... and then (due to updated symlinks) also calls to cc and c++ get caught!

Thanks I didn't know about update-ccache-symlinks, I was creating c++ link with a script for a project and it was working but not for another project (still don't know why, the link was fine), update-ccache-symlinks solved. — Alex, May 29, 2019 at 12:31

Nadir SOUALEM · Answer 8 · 2009-11-30 10:25:52Z

In my opinion the best way is to symlink gcc,g++ to ccache, but if you would like to use within cmake, try this:

export CC="ccache gcc" CXX="ccache g++" cmake ...

jpr42 · Answer 9 · 2022-10-19 05:03:58Z

Here are 2 methods I think are clean/robust, and also don't pollute your CMake code.

1.) Set environment variables

This method is nice since you don't have to individually set it up for each CMake project. The con is you may not want ccache for each CMake project.

# Requires CMake 3.17 (https://cmake.org/cmake/help/latest/envvar/CMAKE_LANG_COMPILER_LAUNCHER.html)
export CMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/ccache
export CMAKE_C_COMPILER_LAUNCHER=/usr/bin/ccache

2.) Pass in cache variables during project configuration

Con a bit annoying to do for each project. This can be negated by your IDE though.

# Requires CMake 3.4
$ cmake ... -D CMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/ccache \
  -D CMAKE_C_COMPILER_LAUNCHER=/usr/bin/ccache

NOTE: It isn't really necessary to specify the full path.

If ccache is in your path you can just specify ccache instead.

export CMAKE_CXX_COMPILER_LAUNCHER=ccache
export CMAKE_C_COMPILER_LAUNCHER=ccache

ephemerr · Answer 10 · 2021-11-18 08:41:50Z

It is extending @Nicolas answer.

Add following line to your cmake file:

list(PREPEND CMAKE_PROGRAM_PATH /usr/lib/ccache)

Or add it as argument to cmake configuration step:

cmake -DCMAKE_PROGRAM_PATH=/usr/lib/ccache

sinferwu

Using ccache with CMake

CCache

How to Use CCache with CMake?

10 Answers

NOTE: It isn't really necessary to specify the full path.

公告