I've asked this question on Stack Overflow almost a year ago with no useful
responses (with the same topic if you wish to search for it), so I'm trying
my luck here.

I work on a large commercial C++ project comprised of a couple dozen
dynamically linked shared libraries, each of which has many associated unit
tests. Many libs are also dependent on other libs because a lib for some
specific functionality will use the code from one of the more common libs.
And finally of course there are the production executables which depend on
the libs.

There is no question that a change in the API (a header file) of some core
common lib should trigger a major recompilation of nearly the entire
system. But typically there is only a change in some function's
implementation, and the only file compiled is the modified .cpp file, and
in theory just the modified lib would need to be linked - thanks to dynamic
linking there should be no need to relink anything else. But CMake goes
ahead and does it anyway: after relinking the lib it relinks all the unit
tests associated with that lib. Then it relinks all the libs in that lib's
dependency tree and all their unit tests. Finally it relinks the production
executables. Due to the scale of the project this takes a lot of precious

I have reproduced this behavior with a simple project based on the example
at cmake.org/examples (comments removed for brevity and lib type changed to
shared). My system is Ubuntu 16 on an Intel PC and my CMake version is

Start with an empty directory. Create subdirectories Demo and Hello and
then create these files:

* CMakeLists.txt

cmake_minimum_required (VERSION 2.8.11)
project (HELLO)
add_subdirectory (Hello)
add_subdirectory (Demo)

* Demo/CMakeLists.txt

add_executable (helloDemo demo.cpp)
target_link_libraries (helloDemo LINK_PUBLIC Hello)

* Demo/demo.cpp

#include "hello.h"
int main() { hello(); }

* Hello/CMakeLists.txt

add_library (Hello SHARED hello.cpp)
target_include_directories (Hello PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

* Hello/hello.h

void hello();

* Hello/hello.cpp

#include <stdio.h>
void hello() { printf("hello!\n"); }

* now run the commands:

mkdir build
cd build
cmake ../

* You may now execute Demo/helloDemo and see hello!.

Now, touch Hello/hello.cpp and make again. You will see that libHello is
built and linked as expected, but then the helloDemo executable is also
relinked ("Linking CXX executable helloDemo"). The latter step is
completely redundant; even if hello.cpp is modified to print a different
string the relinked executable remains binary identical.

Is there a way to prevent these redundant build actions? This would be a
huge time saver for us.

Thank you,


Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 

Follow this link to subscribe/unsubscribe:

Reply via email to