Issue559 prototype

build_configs.py

@@ -4,6 +4,14 @@
 # USE_GLIBCXX_DEBUG is not compatible with USE_LP (see issue983).
 glibcxx_debug = ["-DCMAKE_BUILD_TYPE=Debug", "-DUSE_LP=NO", "-DUSE_GLIBCXX_DEBUG=YES"]
 minimal = ["-DCMAKE_BUILD_TYPE=Release", "-DDISABLE_LIBRARIES_BY_DEFAULT=YES"]
+prototype = ["-DCMAKE_BUILD_TYPE=Release",
+             "-DDISABLE_LIBRARIES_BY_DEFAULT=YES",
+             "-DLIBRARY_ITERATED_SEARCH_ENABLED=YES",
+             "-DLIBRARY_CORE_TASKS_ENABLED=YES",
+             "-DLIBRARY_PLUGIN_EAGER_ENABLED=YES",
+             "-DLIBRARY_PLUGIN_ASTAR_ENABLED=YES",
+             "-DLIBRARY_LANDMARK_CUT_HEURISTIC_ENABLED=YES",
+             "-DLIBRARY_BLIND_SEARCH_HEURISTIC_ENABLED=YES"]
 
-DEFAULT = "release"
+DEFAULT = "prototype"
 DEBUG = "debug"

driver/aliases.py

@@ -141,6 +141,79 @@ def _get_lama(pref):
 ALIASES["seq-opt-lmcut"] = [
     "--search", "astar(lmcut())"]
 
+ALIASES["issue559_test1"] = [
+    "--search",
+    "let(h, lmcut(description=\"AllTimeLMcut\"),"
+    " iterated([astar(description=\"ASTAR_1\",eval=h),"
+    "           eager(tiebreaking([sum([g(\"my_G_Eval\"), "
+    "                                   h]), "
+    "                              h],"
+    "                             unsafe_pruning=false"
+    "                            ),"
+    "                 reopen_closed=true,"
+    "                 f_eval=sum([g(), "
+    "                             h]))"
+    "          ]))"] # TODO issue559 remove this
+ALIASES["issue559_test2"] = [
+    "--search",
+    "let(h, lmcut(description=\"AllTimeLMcut\"),"
+    " iterated([astar(description=\"ASTAR_1\",eval=h),"
+    "           eager(tiebreaking([sum([g(\"my_G_Eval\"), "
+    "                                   h]), "
+    "                              h],"
+    "                             unsafe_pruning=false"
+    "                            ),"
+    "                 reopen_closed=true,"
+    "                 f_eval=sum([g(), "
+    "                             h])),"
+    "           eager(tiebreaking([sum([g(), "
+    "                                   blind()]), "
+    "                              blind()],"
+    "                             unsafe_pruning=false"
+    "                            )"
+    "                 ,description=\"eager3\")"
+    "          ],pass_bound=false))"] # TODO issue559 remove this
+ALIASES["issue559_test3"] = [
+    "--search",
+    "let(h, lmcut(description=\"AllTimeLMcut\"),"
+    " iterated([astar(description=\"ASTAR_1\",eval=h),"
+    "           eager(tiebreaking([sum([g(\"my_G_Eval\"), "
+    "                                   h]), "
+    "                              h],"
+    "                             unsafe_pruning=false"
+    "                            ),"
+    "                 reopen_closed=true,"
+    "                 f_eval=sum([g(), "
+    "                             h])),"
+    "           eager(tiebreaking([sum([g(), "
+    "                                   blind(transform=adapt_costs(normal))]), "
+    "                              blind()],"
+    "                             unsafe_pruning=false"
+    "                            )"
+    "                 ,description=\"eager3\")"
+    "          ],pass_bound=false))"] # TODO issue559 remove this
+ALIASES["issue559_test4"] = [
+    "--search",
+    "let(h, lmcut(description=\"AllTimeLMcut\"),"
+    " iterated("
+    "[iterated([astar(description=\"ASTAR_1\",eval=h),"
+    "          eager(tiebreaking([sum([g(\"my_G_Eval\"), "
+    "                                   h]), "
+    "                              h],"
+    "                             unsafe_pruning=false"
+    "                            ),"
+    "                 reopen_closed=true,"
+    "                 f_eval=sum([g(), "
+    "                             h]))"
+    "],pass_bound=false), iterated(["
+    "           eager(tiebreaking([sum([g(), "
+    "                                   blind(transform=adapt_costs(normal))]), "
+    "                              blind()],"
+    "                             unsafe_pruning=false"
+    "                            )"
+    "                 ,description=\"eager3\")"
+    "          ])"
+    "],pass_bound=false))"] # TODO issue559 remove this
 
 PORTFOLIOS = {}
 for portfolio in os.listdir(PORTFOLIO_DIR):

src/search/abstract_task.cc

@@ -15,7 +15,11 @@ ostream &operator<<(ostream &os, const FactPair &fact_pair) {
     return os;
 }
 
-static class AbstractTaskCategoryPlugin : public plugins::TypedCategoryPlugin<AbstractTask> {
+TaskIndependentAbstractTask::TaskIndependentAbstractTask()
+    : TaskIndependentComponent("abstract_task", utils::Verbosity::NORMAL) {
+}
+
+static class AbstractTaskCategoryPlugin : public plugins::TypedCategoryPlugin<TaskIndependentAbstractTask> {
 public:
     AbstractTaskCategoryPlugin() : TypedCategoryPlugin("AbstractTask") {
         // TODO: Replace empty string by synopsis for the wiki page.

src/search/abstract_task.h

@@ -1,6 +1,7 @@
 #ifndef ABSTRACT_TASK_H
 #define ABSTRACT_TASK_H
 
+#include "component.h"
 #include "operator_id.h"
 
 #include "algorithms/subscriber.h"
@@ -48,7 +49,7 @@ inline void feed(HashState &hash_state, const FactPair &fact) {
 }
 }
 
-class AbstractTask : public subscriber::SubscriberService<AbstractTask> {
+class AbstractTask : public subscriber::SubscriberService<AbstractTask>, public Component {
 public:
     AbstractTask() = default;
     virtual ~AbstractTask() override = default;
@@ -103,4 +104,10 @@ class AbstractTask : public subscriber::SubscriberService<AbstractTask> {
         const AbstractTask *ancestor_task) const = 0;
 };
 
+class TaskIndependentAbstractTask : public TaskIndependentComponent<AbstractTask> {
+public:
+    explicit TaskIndependentAbstractTask();
+    virtual ~TaskIndependentAbstractTask() override = default;
+};
+
 #endif

src/search/command_line.cc

@@ -80,19 +80,19 @@ static vector<string> replace_old_style_predefinitions(const vector<string> &arg
     return new_args;
 }
 
-static shared_ptr<SearchAlgorithm> parse_cmd_line_aux(const vector<string> &args) {
+static shared_ptr<TaskIndependentSearchAlgorithm> parse_cmd_line_aux(const vector<string> &args) {
     string plan_filename = "sas_plan";
     int num_previously_generated_plans = 0;
     bool is_part_of_anytime_portfolio = false;
 
-    using SearchPtr = shared_ptr<SearchAlgorithm>;
-    SearchPtr search_algorithm = nullptr;
+    using TISearchPtr = shared_ptr<TaskIndependentSearchAlgorithm>;
+    TISearchPtr ti_search_algorithm = nullptr;
     // TODO: Remove code duplication.
     for (size_t i = 0; i < args.size(); ++i) {
         string arg = args[i];
         bool is_last = (i == args.size() - 1);
         if (arg == "--search") {
-            if (search_algorithm)
+            if (ti_search_algorithm)
                 input_error("multiple --search arguments defined");
             if (is_last)
                 input_error("missing argument after --search");
@@ -103,7 +103,7 @@ static shared_ptr<SearchAlgorithm> parse_cmd_line_aux(const vector<string> &args
                 parser::ASTNodePtr parsed = parser::parse(tokens);
                 parser::DecoratedASTNodePtr decorated = parsed->decorate();
                 plugins::Any constructed = decorated->construct();
-                search_algorithm = plugins::any_cast<SearchPtr>(constructed);
+                ti_search_algorithm = plugins::any_cast<TISearchPtr>(constructed);
             } catch (const utils::ContextError &e) {
                 input_error(e.get_message());
             }
@@ -154,16 +154,16 @@ static shared_ptr<SearchAlgorithm> parse_cmd_line_aux(const vector<string> &args
         }
     }
 
-    if (search_algorithm) {
-        PlanManager &plan_manager = search_algorithm->get_plan_manager();
+    if (ti_search_algorithm) {
+        PlanManager &plan_manager = ti_search_algorithm->get_plan_manager();
         plan_manager.set_plan_filename(plan_filename);
         plan_manager.set_num_previously_generated_plans(num_previously_generated_plans);
         plan_manager.set_is_part_of_anytime_portfolio(is_part_of_anytime_portfolio);
     }
-    return search_algorithm;
+    return ti_search_algorithm;
 }
 
-shared_ptr<SearchAlgorithm> parse_cmd_line(
+shared_ptr<TaskIndependentSearchAlgorithm> parse_cmd_line(
     int argc, const char **argv, bool is_unit_cost) {
     vector<string> args;
     bool active = true;

src/search/command_line.h

@@ -4,9 +4,9 @@
 #include <memory>
 #include <string>
 
-class SearchAlgorithm;
+class TaskIndependentSearchAlgorithm;
 
-extern std::shared_ptr<SearchAlgorithm> parse_cmd_line(
+extern std::shared_ptr<TaskIndependentSearchAlgorithm> parse_cmd_line(
     int argc, const char **argv, bool is_unit_cost);
 
 extern std::string usage(const std::string &progname);

src/search/component.h

@@ -0,0 +1,64 @@
+#ifndef COMPONENT_H
+#define COMPONENT_H
+
+#include "utils/logging.h"
+#include "utils/hash.h"
+
+#include <memory>
+
+class AbstractTask;
+
+class Component {
+public:
+    virtual ~Component() = default;
+};
+
+class TaskIndependentComponentBase {
+};
+
+using ComponentMap = utils::HashMap<const TaskIndependentComponentBase *,
+                                    std::shared_ptr<Component>>;
+
+template<typename AbstractProduct>
+class TaskIndependentComponent : public TaskIndependentComponentBase {
+protected:
+    const std::string description;
+    const utils::Verbosity verbosity;
+    mutable utils::LogProxy log;
+public:
+    explicit TaskIndependentComponent(const std::string &description,
+                                      utils::Verbosity verbosity)
+        : description(description), verbosity(verbosity),
+          log(utils::get_log_for_verbosity(verbosity)) {
+    }
+    virtual ~TaskIndependentComponent() = default;
+    std::string get_description() const {return description;}
+    std::shared_ptr<AbstractProduct> get_task_specific(
+        [[maybe_unused]] const std::shared_ptr<AbstractTask> &task,
+        std::unique_ptr<ComponentMap> &component_map, int depth) const {
+        std::shared_ptr<AbstractProduct> component;
+        const TaskIndependentComponentBase *key =
+            static_cast<const TaskIndependentComponentBase *>(this);
+        if (component_map->count(key)) {
+            log << std::string(depth, ' ')
+                << "Reusing task specific component '" << description
+                << "'..." << std::endl;
+            component = dynamic_pointer_cast<AbstractProduct>(
+                component_map->at(key));
+        } else {
+            log << std::string(depth, ' ')
+                << "Creating task specific component '" << description
+                << "'..." << std::endl;
+            component = create_task_specific(task, component_map, depth);
+            component_map->emplace(key, component);
+        }
+        return component;
+    }
+
+    virtual std::shared_ptr<AbstractProduct> create_task_specific(
+        const std::shared_ptr<AbstractTask> &task,
+        std::unique_ptr<ComponentMap> &component_map,
+        int depth) const = 0;
+};
+
+#endif

src/search/evaluator.cc

@@ -74,24 +74,29 @@ int Evaluator::get_cached_estimate(const State &) const {
     ABORT("Called get_cached_estimate when estimate is not cached.");
 }
 
+TaskIndependentEvaluator::TaskIndependentEvaluator(
+    bool use_for_reporting_minima, bool use_for_boosting,
+    bool use_for_counting_evaluations,
+    const std::string &description, utils::Verbosity verbosity)
+    : TaskIndependentComponent(description, verbosity),
+      use_for_reporting_minima(use_for_reporting_minima),
+      use_for_boosting(use_for_boosting),
+      use_for_counting_evaluations(use_for_counting_evaluations) {
+}
+
 void add_evaluator_options_to_feature(
     plugins::Feature &feature, const string &description) {
-    feature.add_option<string>(
-        "description",
-        "description used to identify evaluator in logs",
-        "\"" + description + "\"");
-    utils::add_log_options_to_feature(feature);
+    utils::add_log_options_to_feature(feature, description);
 }
 
 tuple<string, utils::Verbosity> get_evaluator_arguments_from_options(
     const plugins::Options &opts) {
     return tuple_cat(
-        make_tuple(opts.get<string>("description")),
         utils::get_log_arguments_from_options(opts)
         );
 }
 
-static class EvaluatorCategoryPlugin : public plugins::TypedCategoryPlugin<Evaluator> {
+static class EvaluatorCategoryPlugin : public plugins::TypedCategoryPlugin<TaskIndependentEvaluator> {
 public:
     EvaluatorCategoryPlugin() : TypedCategoryPlugin("Evaluator") {
         document_synopsis(

src/search/evaluator.h

@@ -1,6 +1,8 @@
 #ifndef EVALUATOR_H
 #define EVALUATOR_H
 
+#include "abstract_task.h"
+#include "component.h"
 #include "evaluation_result.h"
 
 #include "utils/logging.h"
@@ -14,7 +16,7 @@ namespace plugins {
 class Options;
 }
 
-class Evaluator {
+class Evaluator : public Component {
     const std::string description;
     const bool use_for_reporting_minima;
     const bool use_for_boosting;
@@ -99,6 +101,19 @@ class Evaluator {
     virtual int get_cached_estimate(const State &state) const;
 };
 
+class TaskIndependentEvaluator : public TaskIndependentComponent<Evaluator> {
+    const bool use_for_reporting_minima;
+    const bool use_for_boosting;
+    const bool use_for_counting_evaluations;
+public:
+    explicit TaskIndependentEvaluator(
+        bool use_for_reporting_minima, bool use_for_boosting,
+        bool use_for_counting_evaluations,
+        const std::string &description, utils::Verbosity verbosity);
+    virtual ~TaskIndependentEvaluator() = default;
+};
+
+
 extern void add_evaluator_options_to_feature(
     plugins::Feature &feature, const std::string &description);
 

src/search/evaluators/combining_evaluator.cc

@@ -51,18 +51,28 @@ void CombiningEvaluator::get_path_dependent_evaluators(
     for (auto &subevaluator : subevaluators)
         subevaluator->get_path_dependent_evaluators(evals);
 }
+
+
+TaskIndependentCombiningEvaluator::TaskIndependentCombiningEvaluator(
+    vector<shared_ptr<TaskIndependentEvaluator>> subevaluators,
+    const string &description,
+    utils::Verbosity verbosity)
+    : TaskIndependentEvaluator(false, false, false, description, verbosity),
+      subevaluators(subevaluators) {
+}
+
 void add_combining_evaluator_options_to_feature(
     plugins::Feature &feature, const string &description) {
-    feature.add_list_option<shared_ptr<Evaluator>>(
+    feature.add_list_option<shared_ptr<TaskIndependentEvaluator>>(
         "evals", "at least one evaluator");
     add_evaluator_options_to_feature(feature, description);
 }
 
-tuple<vector<shared_ptr<Evaluator>>, const string, utils::Verbosity>
+tuple<vector<shared_ptr<TaskIndependentEvaluator>>, const string, utils::Verbosity>
 get_combining_evaluator_arguments_from_options(
     const plugins::Options &opts) {
     return tuple_cat(
-        make_tuple(opts.get_list<shared_ptr<Evaluator>>("evals")),
+        make_tuple(opts.get_list<shared_ptr<TaskIndependentEvaluator>>("evals")),
         get_evaluator_arguments_from_options(opts)
         );
 }

src/search/evaluators/combining_evaluator.h

@@ -46,10 +46,22 @@ class CombiningEvaluator : public Evaluator {
 
 extern void add_combining_evaluator_options_to_feature(
     plugins::Feature &feature, const std::string &description);
-extern std::tuple<std::vector<std::shared_ptr<Evaluator>>,
+extern std::tuple<std::vector<std::shared_ptr<TaskIndependentEvaluator>>,
                   const std::string, utils::Verbosity>
 get_combining_evaluator_arguments_from_options(
     const plugins::Options &opts);
+
+
+class TaskIndependentCombiningEvaluator : public TaskIndependentEvaluator {
+protected:
+    std::vector<std::shared_ptr<TaskIndependentEvaluator>> subevaluators;
+public:
+    TaskIndependentCombiningEvaluator(
+        std::vector<std::shared_ptr<TaskIndependentEvaluator>> subevaluators,
+        const std::string &description,
+        utils::Verbosity verbosity);
+    virtual ~TaskIndependentCombiningEvaluator() override = default;
+};
 }
 
 #endif