Caching Implicit Dependencies

SCons User Guide 0.98.0
Prev | Chapter 6. Dependencies | Next

# 6.4. Caching Implicit Dependencies

Scanning each file for `#include` lines does take some extra processing time. When you're doing a full build of a large system, the scanning time is usually a very small percentage of the overall time spent on the build. You're most likely to notice the scanning time, however, when you rebuild all or part of a large system: SCons will likely take some extra time to "think about" what must be built before it issues the first build command (or decides that everything is up to date and nothing must be rebuilt).

In practice, having SCons scan files saves time relative to the amount of potential time lost to tracking down subtle problems introduced by incorrect dependencies. Nevertheless, the "waiting time" while SCons scans files can annoy individual developers waiting for their builds to finish. Consequently, SCons lets you cache the implicit dependencies that its scanners find, for use by later builds. You can do this by specifying the `--implicit-cache` option on the command line:

           % scons -Q --implicit-cache hello
           cc -o hello.o -c hello.c
           cc -o hello hello.o
           % scons -Q hello
           scons: `hello' is up to date.

If you don't want to specify `--implicit-cache` on the command line each time, you can make it the default behavior for your build by setting the `implicit_cache` option in an `SConscript` file:

           SetOption('implicit_cache', 1)

SCons does not cache implicit dependencies like this by default because the `--implicit-cache` causes SCons to simply use the implicit dependencies stored during the last run, without any checking for whether or not those dependencies are still correct. Specifically, this means `--implicit-cache` instructs SCons to not rebuild "correctly" in the following cases:

- When `--implicit-cache` is used, SCons will ignore any changes that may have been made to search paths (like `$CPPPATH` or `$LIBPATH`,). This can lead to SCons not rebuilding a file if a change to `$CPPPATH` would normally cause a different, same-named file from a different directory to be used.

- When `--implicit-cache` is used, SCons will not detect if a same-named file has been added to a directory that is earlier in the search path than the directory in which the file was found last time.

## 6.4.1. The `--implicit-deps-changed` Option

When using cached implicit dependencies, sometimes you want to "start fresh" and have SCons re-scan the files for which it previously cached the dependencies. For example, if you have recently installed a new version of external code that you use for compilation, the external header files will have changed and the previously-cached implicit dependencies will be out of date. You can update them by running SCons with the `--implicit-deps-changed` option:

             % scons -Q --implicit-deps-changed hello
             cc -o hello.o -c hello.c
             cc -o hello hello.o
             % scons -Q hello
             scons: `hello' is up to date.

In this case, SCons will re-scan all of the implicit dependencies and cache updated copies of the information.

## 6.4.2. The `--implicit-deps-unchanged` Option

By default when caching dependencies, SCons notices when a file has been modified and re-scans the file for any updated implicit dependency information. Sometimes, however, you may want to force SCons to use the cached implicit dependencies, even if the source files changed. This can speed up a build for example, when you have changed your source files but know that you haven't changed any `#include` lines. In this case, you can use the `--implicit-deps-unchanged` option:

             % scons -Q --implicit-deps-unchanged hello
             cc -o hello.o -c hello.c
             cc -o hello hello.o
             % scons -Q hello
             scons: `hello' is up to date.

In this case, SCons will assume that the cached implicit dependencies are correct and will not bother to re-scan changed files. For typical builds after small, incremental changes to source files, the savings may not be very big, but sometimes every bit of improved performance counts.

Prev | Home | Next
Implicit Dependencies: The `$CPPPATH` Construction Variable | Up | Explicit Dependencies: the `Depends` Function