Jak używać CCache z CMake?

Chciałbym wykonać następujące czynności: Jeśli CCache jest obecny w PATH, użyj „ccache g ++” do kompilacji, w przeciwnym razie użyj g ++. Spróbowałem napisać mały skrypt my-cmake zawierający

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

ale wygląda na to, że nie działa (uruchomiona make nadal nie używa ccache; sprawdziłem to używając CMAKE_VERBOSE_MAKEFILE na).

Aktualizacja:

Zgodnie z tym linkiem próbowałem zmienić mój skrypt na

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

ale cmake rezygnuje z narzekania, że ​​test nie powiódł się przy użyciu pamięci podręcznej kompilatora (czego można się spodziewać).

Osobiście mam /usr/lib/ccachew swoim $PATH. Ten katalog zawiera mnóstwo dowiązań symbolicznych dla każdej możliwej nazwy, z której kompilator mógłby zostać wywołany (jak gcci gcc-4.3), wszystkie wskazujące na pamięć podręczną.

I nawet nie utworzyłem dowiązań symbolicznych. Ten katalog jest wstępnie wypełniony, kiedy instaluję ccache na Debianie.

Możliwe jest teraz określenie ccache jako programu uruchamiającego dla poleceń kompilacji i poleceń linkowania (od cmake 2.8.0). To działa dla Makefile i generatora Ninja. Aby to zrobić, wystarczy ustawić następujące właściwości:

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)

Możliwe jest również ustawienie tych właściwości tylko dla określonych katalogów lub celów.

W przypadku Ninja jest to możliwe od wersji 3.4. W przypadku XCode Craig Scott podaje obejście w swojej odpowiedzi.

Edycja: Dzięki komentarzowi uprego i Lekensteyn zredagowałem odpowiedź, aby sprawdzić, czy pamięć podręczna jest dostępna przed użyciem jej jako programu uruchamiającego i dla których generatorów można użyć programu uruchamiającego kompilację.

Edit2: @Emilio Cobos zaleca unikanie robienia tego w części łączącej, ponieważ pamięć podręczna nie poprawia szybkości łączenia i może zepsuć inne typy pamięci podręcznej, takie jak sccache

Od CMAKE 3.4 możesz:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

Od CMake 3.1 można używać ccache z generatorem Xcode, a Ninja jest obsługiwany od CMake 3.4. Ninja będzie honorować RULE_LAUNCH_COMPILEtak samo, jak generator Unix Makefiles (więc odpowiedź @ Babcool prowadzi również do Ninja), ale uzyskanie pamięci podręcznej działającej dla generatora Xcode wymaga trochę więcej pracy. Poniższy artykuł wyjaśnia szczegółowo tę metodę, koncentrując się na ogólnej implementacji, która działa dla wszystkich trzech generatorów CMake i nie przyjmuje żadnych założeń dotyczących konfigurowania dowiązań symbolicznych ccache lub używanego kompilatora (nadal pozwala CMake zdecydować o kompilatorze):

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

Ogólna istota artykułu jest następująca. Początek CMakeLists.txtpliku powinien wyglądać tak:

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

Dwa pliki szablonów skryptów launch-c.ini launch-cxx.inwyglądają następująco (powinny znajdować się w tym samym katalogu co CMakeLists.txtplik):

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

Powyższe używa RULE_LAUNCH_COMPILEtylko dla Unix Makefiles i Ninja, ale dla generatora Xcode opiera się na pomocy z obsługi CMAKE_XCODE_ATTRIBUTE_...zmiennych CMake . Ustawienie CCi CXXzdefiniowanych przez użytkownika Xcode atrybutów kontrolować polecenia kompilator LDi LDPLUSPLUSdla polecenia łącznikowej nie, o ile mogę powiedzieć, udokumentowany cechą projektów Xcode, ale wydaje się do pracy. Jeśli ktokolwiek może potwierdzić, że jest on oficjalnie obsługiwany przez Apple, zaktualizuję odpowiednio powiązany artykuł i tę odpowiedź.

Nie lubiłem ustawiać linku symbolicznego od g++do ccache. ICXX="ccache g++" nie zadziałało dla mnie, ponieważ pewien przypadek testowy cmake chciał mieć tylko program kompilujący bez atrybutów.

Więc zamiast tego użyłem małego skryptu bash:

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

i zapisał go jako plik wykonywalny w /usr/bin/ccache-g++.

Następnie C skonfigurował cmake do użycia /usr/bin/ccache-g++jako kompilator C ++. W ten sposób przechodzi testy cmake i czuję się bardziej komfortowo niż posiadanie linków symbolicznych, o których mógłbym zapomnieć za 2 lub 3 tygodnie, a potem być może zastanawiam się, czy coś nie działa ...

Moim zdaniem najlepszym sposobem jest dowiązanie symboliczne gcc, g ++ do ccache, ale jeśli chcesz używać w cmake, spróbuj tego:

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

Zweryfikowałem następujące prace (źródło: ten 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" $*

Aktualizacja : Później zdałem sobie sprawę, że nawet to nie działa. O dziwo działa co drugi raz (innym razem cmake narzeka).

Dodam jeszcze jedną ważną rzecz, o której wcześniej nie było mowy.

Podczas ładowania minimalistycznego systemu kompilacji z obrazu dockera ubunutu: 18.04 zauważyłem, że kolejność instalacji ma znaczenie.

W moim przypadku ccache działał dobrze podczas wywoływania gcc, ale nie udało się przechwycić wywołań tego samego kompilatora pod innymi nazwami: cci c++. Aby w pełni zainstalować ccache, musisz najpierw upewnić się, że wszystkie kompilatory są zainstalowane, lub dodać wywołanie do dowiązań symbolicznych update-ccache dla bezpieczeństwa.

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

... a następnie (ze względu na zaktualizowane dowiązania symboliczne) również wywołania cc i c ++ zostają złapane!