I made one more Makefile change: the LP code is now set up on demand the first
time it is requested via USE_LP (the name of that option was changed, too). I've
updated the documentation at
http://alfons.informatik.uni-freiburg.de/downward/LPBuildInstructions

All of this needs some more practice testing, but I'm sure someone will notice
when the Makefile is buggy, so I'm closing this for now. :-)

Two more Makefile changes:

r4600:
 * The object file directory "obj" is now called ".obj".
 * The object file directory is no longer in the repository.
   Instead, it is svn:ignored and created on demand by the Makefile.
   make clean now deletes the whole .obj directory with rm -rf. (!!!)
   The advantage of this is that renaming/deleting source files
   no longer leaves corpses in the obj directory and that it is no
   longer necessary to manually generate subdirectories in obj when
   adding a subdirectory with source code.

A previous small change I forgot to report:
 * "make PROFILE" should now also work when you don't have the "cleanup-profile"
   script available. But you won't get cleaned up profiles. ;-)
   (This one is already a few revisions old.)
 * As of The "obj" dir is now called ".obj"

OK, -O3 it is for all three planner configurations now.

I'm still adding it individually for all three configurations rather than as a
global option so that it is easier to change e.g. only downward-debug on demand.

Changed in r4602:

Makefile change:
 * CCOPT_DEBUG now also includes -O3, which means that all configurations
   now use -O3.
   The remaining differences between release mode and debug mode are:
   * Release mode defines NDEBUG (which, among other things, disables
     assertions.)
   * Release mode defines -fomit-frame-pointer.
   * Release mode links statically (-static -static-libgcc).

I vote for -O3.

I'm neutral

I agree that complete time is not so important, but incremental build time
should have the same proportions, and from my recent experience working with the
code, -O3 definitely feels slower than -O0 even with incremental work.

Then again, maybe I should just get used to using make -j2. :-)

So should I put you as a vote for -O3, or are you neutral/some other preference?

I don't think *COMPLETE* build time is that important, since after most changes, 
only an incremental build is done. So I think the debug mode can be built with -O3 
without worrying about that.

OK, I've messed around with the Makefile quite a bit. Still needs more testing,
e.g. of the configurations with the LP solver, but first tests at least look OK.

The default target is now the release target. I didn't want the default target
to have an ugly name like "release-search", but I also didn't want to call it
"search", since then it's kind of tough when comparing different revisions to
find out which executables are optimized and which ones are not. Hence I
introduced completely new names:

 * release-search => downward
 * search => downward-debug
 * profile-search => downward-profile

There are a bunch of other changes to the Makefile; it should now be much more
logically structured and easier to modify.
From the commit log (r4593):

Makefile updates:
 * The release target is now the default target. The previous default
   target is now called the debug target.
 * There are now aliases for the three planner targets: release, debug,
   profile.
 * The executable names have changed:
   * "downward" for the release target (was: "release-search")
   * "downward-debug" for the debug target (was: "search")
   * "downward-profile" for the profile target (was: "profile-search")
 * General Makefile refactoring/rewriting. Option names in the Makefile
   are now more consistent.

(Sorry for the length, there's a question for you at the bottom.)



OK, to make a more informed decision which option settings are suitable for
debug stuff, I compiled the code in the current debug ("make") and release
("make release") targets, but varying the optimization levels, trying all common
options (-O0, -O1, -O2, -O3, -Os). I did this on three machines: my office
machine (alfons), my notebook (knopf) and my 9-year-old machine at home
(kruemel). Here are the compilation times after a make distclean, not counting
the time for updating the dependencies (make Makefile.depend):

alfons   -O0  debug     46.019s
alfons   -O0  release   44.935s
alfons   -O1  debug     52.303s
alfons   -O1  release   51.515s
alfons   -O2  debug     64.712s
alfons   -O2  release   63.480s
alfons   -O3  debug     70.312s
alfons   -O3  release   69.284s
alfons   -Os  debug     52.627s
alfons   -Os  release   50.915s

knopf    -O0  debug     52.503s
knopf    -O0  release   51.167s
knopf    -O1  debug     59.464s
knopf    -O1  release   58.475s
knopf    -O2  debug     73.836s
knopf    -O2  release   72.436s
knopf    -O3  debug     80.293s
knopf    -O3  release   79.129s
knopf    -Os  debug     59.808s
knopf    -Os  release   57.783s

kruemel  -O0  debug    229.462s
kruemel  -O0  release  220.154s
kruemel  -O1  debug    238.231s
kruemel  -O1  release  241.359s
kruemel  -O2  debug    312.387s
kruemel  -O2  release  297.371s
kruemel  -O3  debug    321.564s
kruemel  -O3  release  323.088s
kruemel  -Os  debug    237.251s
kruemel  -Os  release  231.818s

This tell us, that

a) I should eventually buy a new machine at home, and
b) on all machines, -O3 takes about 50% longer than -O0, and -O2 is a bit
faster, but not much. (In my limited experience, only -O2 and -O3 are worth it.)

Not sure how important a 50% slowdown is, so I'd like to ask for a show of hands:

 * Should our new debug target (what is now "make" and will be "make debug")
   use -O0 or -O3?

I've been dithering about this a bit. 50% more time can feel quite a lot while
you're working on the code. On the other hand, running the planner with -O0 is
so much different from -O3 that -O0 is pretty much useless for any kind of
debugging/development where planner runtime matters.

I agree with Gabi.

On 24 March 2010 19:36, Gabriele Roeger
<roeger@informatik.uni-freiburg.de> wrote:
> I am fine with -O3 as default (if I do not want to spend the
> compile time, I can still temporarily change it to -O2). I don't
> think it makes a difference whether the make target is named
> search or debug-search, more interesting is what is used as
> default  (when running "make" with no arguments).
>

I am fine with -O3 as default (if I do not want to spend the
compile time, I can still temporarily change it to -O2). I don't
think it makes a difference whether the make target is named
search or debug-search, more interesting is what is used as
default  (when running "make" with no arguments).

Since we use -O3 for all actual experiments, I think we *want* to know as early
as possible if something is going wrong with that setting, so if there are
issues with that, it'd be a bad idea not to test it. If there is suspicion of a
compiler bug, it's easy enough to make a temporary local change to the Makefile
to try out other options.

(Besides, I've never seen wrong-code-producing compiler bugs in 13 years --
although I've seen a bunch of cases with -O3 where people *thought* it was a
compiler bug, but it turned out a subtlety in the C++ standard. I've also seen
many cases of "it works with -O2 but not with -O3 so it's a compiler bug" that
were due to bugs in the code that only mattered with high optimization levels.)

Gabi, Silvia, your opinions? (If we can't agree on this, there's also the option
of allowing local customizations of the Makefile.)

I have noticed some problems with -O3 in the past (incorrect results).
I suggest we keep the debug configuration to at most O2, so we can 
easily check if some bug is the result of incorrect compiler optimizations

Sounds good, although I think maybe debug-search should have -O3, too, and the
only difference would be the NDEBUG setting and static linking.

Anyone in favour of keeping the "debug" configuration -O0 as it currently is?
Main advantage: faster compilation time. Main disadvantage: runs very slowly.

We can also change the name of search to debug-search
and release-search to search (and make it the default make target).
That way we don't have to change anything in the code except for the Makefile

Before we release the planner, we should switch to using -O3 by default since
people are likely to miss the subtlety of having to do "make release" and then
"./release-search", even if we provide a README and scripts. (It has happened
before to Carmel.)

It would be nice to still have assertions on by default though, so we should
probably still have a regular version and a (slightly) faster "release" version.
Might make sense to compare if we have any expensive assertions, actually... if
not, maybe it's not even worth bothering with NDEBUG.