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 hellocc -o hello.o -c hello.c cc -o hello hello.o %scons -Q helloscons: `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.
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 hellocc -o hello.o -c hello.c cc -o hello hello.o %scons -Q helloscons: `hello' is up to date.
In this case, SCons will re-scan all of the implicit dependencies and cache updated copies of the information.
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 hellocc -o hello.o -c hello.c cc -o hello hello.o %scons -Q helloscons: `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.