Wie verwende ich CCache mit CMake?

Ich möchte Folgendes tun: Wenn CCache in PATH vorhanden ist, verwenden Sie "ccache g ++" zum Kompilieren, andernfalls verwenden Sie g ++. Ich habe versucht, ein kleines my-cmake-Skript zu schreiben, das Folgendes enthält

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

aber es scheint nicht zu funktionieren (das Ausführen von make verwendet immer noch keinen Ccache; ich habe dies mit CMAKE_VERBOSE_MAKEFILE aktiviert).

Aktualisieren:

Über diesen Link habe ich versucht, mein Skript in zu ändern

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

cmake klagt jedoch darüber, dass ein Test bei Verwendung des Compiler-Ccaches fehlgeschlagen ist (was zu erwarten ist).

Ich persönlich habe /usr/lib/ccachein meinem $PATH. Dieses Verzeichnis enthält viele Symlinks für jeden möglichen Namen, von dem aus der Compiler aufgerufen werden kann (wie gccund gcc-4.3), die alle auf ccache verweisen.

Und ich habe nicht einmal die Symlinks erstellt. Dieses Verzeichnis wird vorgefüllt, wenn ich ccache auf Debian installiere.

Es ist jetzt möglich, ccache als Starter für Kompilierungsbefehle und Verknüpfungsbefehle anzugeben (seit cmake 2.8.0). Das funktioniert für Makefile und Ninja Generator. Legen Sie dazu einfach die folgenden Eigenschaften fest:

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)

Es ist auch möglich, diese Eigenschaften nur für bestimmte Verzeichnisse oder Ziele festzulegen.

Für Ninja ist dies seit Version 3.4 möglich. Für XCode gibt Craig Scott eine Problemumgehung in seiner Antwort.

Bearbeiten: Dank des Kommentars von uprego und Lekensteyn habe ich die Antwort bearbeitet, um zu überprüfen, ob ccache verfügbar ist, bevor ich ihn als Launcher verwende, und für welche Generatoren ein Compile-Launcher verwendet werden kann.

Edit2: @Emilio Cobos hat empfohlen, dies für den Verknüpfungsteil zu vermeiden, da der Ccache die Verknüpfungsgeschwindigkeit nicht verbessert und mit anderen Cache-Typen wie sccache in Konflikt geraten kann

Ab CMAKE 3.4 können Sie:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

Ab CMake 3.1 ist es möglich, ccache mit dem Xcode-Generator zu verwenden, und Ninja wird ab CMake 3.4 unterstützt. Ninja wird RULE_LAUNCH_COMPILEgenau wie der Unix Makefiles-Generator ehren (also bringt Sie die Antwort von @ Babcool auch für Ninja dorthin), aber Ccache für den Xcode-Generator zum Laufen zu bringen, erfordert etwas mehr Arbeit. Der folgende Artikel erläutert die Methode im Detail, wobei der Schwerpunkt auf einer allgemeinen Implementierung liegt, die für alle drei CMake-Generatoren funktioniert, und keine Annahmen zum Einrichten von Ccache-Symlinks oder des verwendeten zugrunde liegenden Compilers getroffen werden (CMake kann weiterhin den Compiler bestimmen):

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

Der allgemeine Kern des Artikels lautet wie folgt. Der Anfang Ihrer CMakeLists.txtDatei sollte ungefähr so ​​eingerichtet sein:

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()

Die beiden Skriptvorlage Dateien launch-c.inund launch-cxx.insieht wie folgt aus (sie im selben Verzeichnis wie das sein sollte CMakeLists.txtDatei):

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}" "$@"

Das Obige wird RULE_LAUNCH_COMPILEallein für Unix Makefiles und Ninja verwendet, aber für den Xcode-Generator ist es auf die Hilfe der CMake- CMAKE_XCODE_ATTRIBUTE_...Variablenunterstützung angewiesen . Die Einstellung der CCund CXXbenutzerdefinierten Xcode Attribute den Compiler - Befehl und steuern LDund LDPLUSPLUSfür den Linker - Befehl nicht, soweit ich das beurteilen kann, ein dokumentiertes Merkmal von Xcode - Projekten, aber es zu funktionieren scheint. Wenn jemand bestätigen kann, dass es offiziell von Apple unterstützt wird, werde ich den verlinkten Artikel und diese Antwort entsprechend aktualisieren.

Ich wollte keinen Symlink von g++bis setzen ccache. Und CXX="ccache g++"hat bei mir nicht funktioniert, da einige cmake-Testfälle nur das Compiler-Programm ohne Attribute haben wollten.

Also habe ich stattdessen ein kleines Bash-Skript verwendet:

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

und speicherte es als ausführbare Datei in /usr/bin/ccache-g++.

Anschließend hat C cmake für die Verwendung /usr/bin/ccache-g++als C ++ - Compiler konfiguriert . Auf diese Weise besteht es die cmake-Testfälle und ich fühle mich wohler als Symlinks, die ich in 2 oder 3 Wochen vergessen könnte, und frage mich dann vielleicht, ob etwas nicht funktioniert ...

Meiner Meinung nach ist es am besten, gcc, g ++ mit ccache zu verknüpfen. Wenn Sie es jedoch in cmake verwenden möchten, versuchen Sie Folgendes:

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

Ich habe folgende Arbeiten überprüft (Quelle: dieser 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 : Ich habe später festgestellt, dass auch das nicht funktioniert. Seltsamerweise funktioniert es jedes zweite Mal (das andere Mal beschwert sich cmake).

Lassen Sie mich einen wichtigen Punkt hinzufügen, der hier zuvor nicht erwähnt wurde.

Beim Bootstrapping eines minimalistischen Build-Systems vom Docker-Image ubunutu: 18.04 habe ich festgestellt, dass die Reihenfolge der Installation einen Unterschied macht.

In meinem Fall funktionierte ccache beim Aufrufen einwandfrei gcc, konnte jedoch Aufrufe desselben Compilers mit den anderen Namen nicht abfangen: ccund c++. Um Ccache vollständig zu installieren, müssen Sie sicherstellen, dass alle Compiler zuerst installiert sind, oder einen Aufruf für die Update-Ccache-Symlinks hinzufügen, um die Sicherheit zu gewährleisten.

sudo apt-get install ccache build-essential # and everyhting ... sudo /usr/sbin/update-ccache-symlinks export PATH="/usr/lib/ccache/:$PATH"

... und dann (aufgrund aktualisierter Symlinks) werden auch Aufrufe von cc und c ++ abgefangen!