Back to HomePage.

Usage

Running the planner is a three-step process as explained in Section 3 (pp. 202-203) of the JAIR paper on Fast Downward. The following instructions show how to run these three steps, in sequence, assuming that the preprocessor and search component have been compiled and that you are currently located in the src directory.

If you want to run any of the planners based on Fast Downward that participated in IPC 2011, please also check IpcPlanners.

Driver script

We recommend using the src/fast-downward.py script for running Fast Downward. It supports running all three planner steps or a subset of them and automatically chooses the right steps depending on the given input. To see the list of options run

./fast-downward.py --help

Below are the instructions for running individual steps without the driver script.

Translator

translate/translate.py [DOMAIN] PROBLEM

• DOMAIN (filename): PDDL domain file

• PROBLEM (filename): PDDL problem file

If the domain file is not given, the planner will try to infer a likely name from the problem file name, using the conventions used at the various IPCs. (If in doubt if this will work for you, just try it out.)

Note: Creates a file called output.sas.

Preprocessor

preprocess/preprocess < OUTPUT.SAS

• OUTPUT.SAS (filename): translator output

Note: Creates a file called output.

Search component

search/downward OPTIONS < OUTPUT

• OPTIONS: Examples below. See OptionSyntax and Doc/Overview for details.

• OUTPUT (filename): preprocessor output

Exit codes

The list of exit codes for the search component is defined in src/search/utilities.h and explained below:

Examples

A* search

   1 # landmark-cut heuristic
   2  ./fast-downward.py output --search "astar(lmcut())"
   3 
   4 # iPDB heuristic with default settings
   5  ./fast-downward.py output --search "astar(ipdb())"
   6 
   7 # blind heuristic
   8  ./fast-downward.py output --search "astar(blind())"

Lazy greedy best-first search with preferred operators and the queue alternation method

   1 ## using FF heuristic and context-enhanced additive heuristic (previously: "fFyY")
   2  ./fast-downward.py output \
   3     --heuristic "hff=ff()" --heuristic "hcea=cea()" \
   4     --search "lazy_greedy([hff, hcea], preferred=[hff, hcea])" \
   5            
   6 
   7 ## using FF heuristic (previously: "fF")
   8  ./fast-downward.py output \
   9     --heuristic "hff=ff()" \
  10     --search "lazy_greedy(hff, preferred=hff)" \
  11            
  12 
  13 ## using context-enhanced additive heuristic (previously: "yY")
  14  ./fast-downward.py output \
  15     --heuristic "hcea=cea()" \
  16     --search "lazy_greedy(hcea, preferred=hcea)" \
  17 

LAMA 2011

 ./fast-downward.py --alias seq-sat-lama-2011 output

runs the "LAMA 2011 configuration" of the planner. It is not really the same as LAMA 2011 because there have been bug fixes and other changes to the planner since 2011 that affect all configurations (e.g. a more compact state encoding). If you really want the version of the planner that was run in the 2011 competition (bugs and all), we recommend that you obtain it from the IPC 2011 website. Alternatively, use branch ipc-2011-fixes from the repository, but note that the planner usage has changed since that branch was created. Please also check the comments below on 32-bit vs. 64-bit mode.

To find out which actual search options the LAMA 2011 configuration corresponds to, check the source code of the src/driver/aliases.py module.

32-bit mode or 64-bit mode?

Our current codebase (as of November 2011) differs from the IPC versions of our planners in one way: by default, planner executables are compiled in 32-bit mode, while 64-bit was used at IPC 2011. The main differences between 32- vs. 64-bit mode are as follows:

• 64-bit mode is faster than 32-bit mode (in our limited experiments typically by a factor of ~1.1)
• 64-bit mode needs more memory than 32-bit mode (in our limited experiments typically by a factor of ~1.5)
• 64-bit mode can use essentially unbounded amounts of memory, while 32-bit mode can only use 3 GB of user space memory (on typical Linux systems -- numbers may differ on other operating systems and depending on kernel options)

In our experiments, the memory advantage of 32-bit mode tends to outweigh the speed disadvantage, which is why we enable 32-bit mode by default. See http://issues.fast-downward.org/issue213 for details. However, for memory limits substantially beyond 4 GB, you should use 64-bit mode due to the address space limitations of 32-bit mode.

To enable 64-bit, compile the planner with the option DOWNWARD_BITWITH=64, e.g. by running

./build_all distclean
./build_all DOWNWARD_BITWIDTH=64

in the src directory. (If VAL is not currently compiled, the first line may give you an error, which you can ignore.)

Other questions?

Please get in touch! See the HomePage for various contact options.