fixing bugs. case 5 runs. hits infinite loop

Author: connoralittle

src/deadend.cc

@@ -117,21 +117,21 @@ void update_deadends(vector< DeadendTuple* > &failed_states) {
 
         ////////////////////////////////////////////
 
-        // Check to see if we have any consistent "all-fire" operators
-        reg_items.clear();
-        PR2.general.regressable_cond_ops->generate_consistent_items(*failed_state,
-                                                                    reg_items,
-                                                                    PR2.deadend.regress_trigger_only);
+        // // Check to see if we have any consistent "all-fire" operators
+        // reg_items.clear();
+        // PR2.general.regressable_cond_ops->generate_consistent_items(*failed_state,
+        //                                                             reg_items,
+        //                                                             PR2.deadend.regress_trigger_only);
 
-        // For each operator, create a new deadend avoidance pair
-        for (auto item : reg_items) {
+        // // For each operator, create a new deadend avoidance pair
+        // for (auto item : reg_items) {
 
-            RegressableOperator *ro = (RegressableOperator*)item;
+        //     RegressableOperator *ro = (RegressableOperator*)item;
 
-            fsaps.push_back(new FSAP(failed_state->regress(ro->op, ro->op.all_fire_context),
-                                     ro->op));
+        //     fsaps.push_back(new FSAP(failed_state->regress(ro->op, ro->op.all_fire_context),
+        //                              ro->op));
 
-        }
+        // }
 
         ////////////////////////////////////////////
 

src/fd_integration/partial_state.cc

@@ -26,7 +26,7 @@ PR2State::PR2State(std::vector<int> init_vals) {
 }
 
 PR2State::PR2State(const State &state) {
-    // _allocate();
+    _allocate(PR2.general.num_vars);
     for (auto var : state)
         vars[var.get_variable().get_id()] = var.get_value();
 }

src/fd_integration/partial_state.h

@@ -15,8 +15,10 @@ class StateInterface;
 class PR2State : public StateInterface {
     std::vector<int> vars; // values for vars
     std::vector< std::pair<int,int> > * _varvals = NULL; // varval pairs for partial states
-    // void _allocate();
-    // void _deallocate();
+    void _allocate(int size) {
+        vars.reserve(size);
+    }
+    void _deallocate() {}
     // void _copy_buffer_from_state(const PR2State &state);
 
 public:

src/fd_integration/pr2_search_algorithm.cc

@@ -67,7 +67,7 @@ unique_ptr<SearchAlgorithm> PR2Search::get_search_engine() {
         numeric_limits<double>::infinity(),
         "PR2 Search",
         utils::Verbosity::SILENT,
-        weak_task,
+        tasks::g_root_task,
         new DeadendAwareSuccessorGenerator());
 
     return unique_ptr<SearchAlgorithm>(engine);

src/pr2.cc

@@ -273,6 +273,9 @@ void PR2Wrapper::generate_nondet_operator_mappings() {
 
     for (auto op : PR2.proxy->get_operators()) {
         //If not in the mapping yet
+        PR2.general.conditional_mask.push_back(new vector<int>());
+        PR2.deadend.nondetop2fsaps.push_back(new vector< FSAP* >());
+
         if (nondet_name_to_index.find(op.get_nondet_name()) == nondet_name_to_index.end()) {
             nondet_name_to_index[op.get_nondet_name()] = current_nondet_index;
             PR2.general.nondet_mapping.push_back(vector<int>());
@@ -306,50 +309,6 @@ void PR2Wrapper::generate_nondet_operator_mappings() {
     }
 
     PR2.proxy->set_nondet_index_map(*nondet_index_map);
-
-    //TODO
-    //Reinstantiate conditional mask and possibly nondetop2fspas
-    //They were previously global and not instantiated anywhere
-
-
-    // /* Build the data structures required for mapping between the
-    //  * deterministic actions and their non-deterministic equivalents. */
-    // int cur_nondet = 0;
-    // for (auto op : PR2.proxy->get_operators()) {
-
-    //     int nondet_index = -1;
-
-    //     PR2.general.conditional_mask.push_back(new vector<int>());
-    //     PR2.deadend.nondetop2fsaps.push_back(new vector< FSAP* >());
-
-    //     if (PRP.general.nondet_index_mapping.find(op.get_nondet_name()) == PRP.general.nondet_index_mapping.end()) {
-
-    //         nondet_index = cur_nondet;
-    //         PRP.general.nondet_index_mapping[op.get_nondet_name()] = cur_nondet;
-
-    //         PRP.general.nondet_mapping.push_back(new vector<GlobalOperator *>());
-    //         PRP.general.conditional_mask.push_back(new vector<int>());
-
-    //         PRP.deadend.nondetop2fsaps.push_back(new vector< FSAP* >());
-
-    //         cur_nondet++;
-
-    //     } else {
-    //         nondet_index = PRP.general.nondet_index_mapping[op.get_nondet_name()];
-    //     }
-
-    //     op.nondet_index = nondet_index;
-    //     PRP.general.nondet_mapping[nondet_index]->push_back(&op);
-    //     op.nondet_outcome = PRP.general.nondet_mapping[nondet_index]->size() - 1;
-
-    //     for (auto eff : op.get_all_effects()) {
-    //         for (auto cond : eff.conditions) {
-    //             vector<int> *var_list = PRP.general.conditional_mask[nondet_index];
-    //             if (find(var_list->begin(), var_list->end(), cond.var) == var_list->end())
-    //                 PRP.general.conditional_mask[nondet_index]->push_back(cond.var);
-    //         }
-    //     }
-    // }
 }
 
 void PR2OperatorProxy::update_nondet_info() {

src/simulator.cc

@@ -193,19 +193,22 @@ bool Simulator::check_1safe() {
     if (PR2.deadend.force_1safe_weak_plans)
         safe_checks = engine->get_plan().size();
 
+    PR2OperatorsProxy ops = PR2.proxy->get_operators();
     for (unsigned i = 0; i < safe_checks; i++) {
-        const PR2OperatorProxy op = PR2.proxy->get_operators()[engine->get_plan()[i]];
+        const PR2OperatorProxy op = ops[engine->get_plan()[i]];
+        PR2OperatorProxy *op_stable = new PR2OperatorProxy(op);
         vector<NondetSuccessor *> successors;
-        new_s = generate_nondet_successors(old_s, &op, successors);
+        new_s = generate_nondet_successors(old_s, op_stable, successors);
 
         for (auto succ : successors) {
             if (is_deadend(*(succ->state))) {
                 PR2State * new_dead_state = new PR2State(*(succ->state));
-                int op_ind = PR2.general.nondet_mapping[op.nondet_index][succ->id];
-                const PR2OperatorProxy bad_op = PR2.proxy->get_operators()[op_ind];
+                int op_ind = PR2.general.nondet_mapping[op_stable->nondet_index][succ->id - 1];
+                const PR2OperatorProxy bad_op = ops[op_ind];
+                PR2OperatorProxy *bad_op_stable = new PR2OperatorProxy(bad_op);
                 if (PR2.deadend.generalize)
                     generalize_deadend(*new_dead_state);
-                new_deadends.push_back(new DeadendTuple(new_dead_state, new PR2State(*old_s), &bad_op));
+                new_deadends.push_back(new DeadendTuple(new_dead_state, new PR2State(*old_s), bad_op_stable));
             }
         }