Come utilizzare CCache con CMake?

Question

Vorrei fare quanto segue: Se CCache è presente in PATH, usare "ccache g ++" per la compilazione, altrimenti usare g ++. Ho provato a scrivere un piccolo my-cmake script contenente

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

ma non sembra funzionare (in esecuzione rendere ancora non usa ccache, ho controllato questo utilizzando CMAKE_VERBOSE_MAKEFILE su).

Aggiornamento:

Come da this link Ho provato a cambiare il mio script per

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

ma cmake balle fuori lamentando che un test fallito sull'uso del ccache compilatore (che può essere previsto).

Answer 1

Personalmente ho /usr/lib/ccache nel mio $PATH. Questa directory contiene un sacco di collegamenti simbolici per ogni possibile nome da cui il compilatore può essere chiamato (come gcc e gcc-4.3), tutti che puntano a ccache.

E non ho nemmeno creato i collegamenti simbolici. Quella directory viene precompilata quando installo ccache su Debian.

Answer 2

ho verificato le seguenti opere (fonte: 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" $* 

Aggiornamento: più tardi mi sono reso conto che anche questo non funziona. Stranamente funziona ogni volta (le altre volte si lamenta).

Answer 3

A mio parere il modo migliore è quello di link simbolico gcc, g ++ per ccache, ma se si desidera utilizzare all'interno CMake, provate questo:

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

Answer 4

Non mi piace impostare un collegamento simbolico da g++ a ccache. E CXX="ccache g++" non ha funzionato per me, dato che alcuni test cmake volevano avere solo il programma di compilazione senza attributi.

così ho usato un piccolo script bash invece:

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

e salvato come un eseguibile in /usr/bin/ccache-g++.

Quindi C ha configurato cmake per utilizzare /usr/bin/ccache-g++ come compilatore C++. In questo modo supera i casi di test cmake e mi sento più a mio agio di avere collegamenti simbolici che potrei dimenticare in 2 o 3 settimane e poi forse mi chiedo se qualcosa non funziona ...

Answer 5

Ora è possibile specificare ccache come launcher per comandi di compilazione e comandi di collegamento (da cmake 2.8.0). Funziona con il generatore Makefile e Ninja. Per fare questo, è sufficiente impostare le seguenti proprietà:

find_program(CCACHE_FOUND ccache) 
if(CCACHE_FOUND) 
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) 
    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) 
endif(CCACHE_FOUND) 

E 'anche possibile impostare queste proprietà solo per directory o target specifici.

Per Ninja, questo è possibile dalla versione 3.4. Per XCode, Craig Scott offre una soluzione alla sua risposta.

Modifica: Grazie a Uprego e al commento di Lekensteyn, ho modificato la risposta per verificare se ccache è disponibile prima di utilizzarlo come launcher e per quali generatori è possibile utilizzare un launcher compilato.

Answer 6

Da CMake 3.1, è possibile utilizzare ccache con il generatore Xcode e Ninja è supportato da CMake 3.4 in poi. Ninja onorerà RULE_LAUNCH_COMPILE proprio come il generatore Unix Makefiles (quindi la risposta di @ Babcool ti porta anche lì per Ninja), ma far funzionare ccache per il generatore Xcode richiede un po 'più di lavoro. Il seguente articolo spiega il metodo in dettaglio, concentrandosi su un'implementazione generale che funziona per tutti e tre i generatori CMake e senza fare ipotesi sull'impostazione di symlink di ccache o sul compilatore sottostante utilizzato (consente comunque a CMake di decidere il compilatore):

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

L'essenza generale dell'articolo è la seguente. L'inizio del file CMakeLists.txt dovrebbe essere istituito qualcosa di simile:

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

Il file di modello due di script launch-c.in e launch-cxx.in aspetto come questo (che dovrebbero essere nella stessa directory del file CMakeLists.txt):

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

È possibile che questo usa RULE_LAUNCH_COMPILE solo per Unix Makefiles e Ninja, ma per il generatore di Xcode si basa su l'aiuto di sostegno CMAKE_XCODE_ATTRIBUTE_... variabili di CMake. L'impostazione degli attributi Xcode definiti dall'utente CC e CXX per controllare il comando del compilatore e LD e LDPLUSPLUS per il comando linker non è, per quanto posso dire, una funzionalità documentata dei progetti Xcode, ma sembra funzionare. Se qualcuno può confermare che è ufficialmente supportato da Apple, aggiornerò l'articolo collegato e questa risposta di conseguenza.

Answer 7

Come di CMAKE 3.4 si può fare:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache