int main( int argc, char *argv[] ) { /* resulting name for ops file */ char ops_file[MAX_LENGTH] = ""; /* same for fct file */ char fct_file[MAX_LENGTH] = ""; struct tms start, end; State current_start, current_end; int i, j; Bool found_plan; times ( &lstart ); /* command line treatment */ if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { ff_usage(); exit( 1 ); } if ( !process_command_line( argc, argv ) ) { ff_usage(); exit( 1 ); } /* make file names */ /* one input name missing */ if ( !gcmd_line.ops_file_name || !gcmd_line.fct_file_name ) { fprintf(stdout, "\nff: two input files needed\n\n"); ff_usage(); exit( 1 ); } /* add path info, complete file names will be stored in * ops_file and fct_file */ sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); /* parse the input files */ /* start parse & instantiation timing */ times( &start ); /* domain file (ops) */ if ( gcmd_line.display_info >= 1 ) { printf("\nff: parsing domain file"); } /* it is important for the pddl language to define the domain before * reading the problem */ load_ops_file( ops_file ); /* problem file (facts) */ if ( gcmd_line.display_info >= 1 ) { printf(" ... done.\nff: parsing problem file"); } load_fct_file( fct_file ); if ( gcmd_line.display_info >= 1 ) { printf(" ... done.\n\n"); } /* This is needed to get all types. */ build_orig_constant_list(); /* last step of parsing: see if it's an ADL domain! */ if ( !make_adl_domain() ) { printf("\nff: this is not an ADL problem!"); printf("\n can't be handled by this version.\n\n"); exit( 1 ); } /* now instantiate operators; */ /************************** * first do PREPROCESSING * **************************/ /* start by collecting all strings and thereby encoding * the domain in integers. */ encode_domain_in_integers(); /* inertia preprocessing, first step: * - collect inertia information * - split initial state into * _ arrays for individual predicates * - arrays for all static relations * - array containing non - static relations */ do_inertia_preprocessing_step_1(); /* normalize all PL1 formulae in domain description: * (goal, preconds and effect conditions) * - simplify formula * - expand quantifiers * - NOTs down */ normalize_all_wffs(); /* translate negative preconds: introduce symmetric new predicate * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) */ translate_negative_preconds(); /* split domain in easy (disjunction of conjunctive preconds) * and hard (non DNF preconds) part, to apply * different instantiation algorithms */ split_domain(); /*********************************************** * PREPROCESSING FINISHED * * * * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * ***********************************************/ build_easy_action_templates(); build_hard_action_templates(); times( &end ); TIME( gtempl_time ); times( &start ); /* perform reachability analysis in terms of relaxed * fixpoint */ perform_reachability_analysis(); times( &end ); TIME( greach_time ); times( &start ); /* collect the relevant facts and build final domain * and problem representations. */ collect_relevant_facts(); times( &end ); TIME( grelev_time ); times( &start ); /* now build globally accessable connectivity graph */ build_connectivity_graph(); times( &end ); TIME( gconn_time ); /*********************************************************** * we are finally through with preprocessing and can worry * * bout finding a plan instead. * ***********************************************************/ times( &start ); /* another quick preprocess: approximate goal orderings and split * goal set into sequence of smaller sets, the goal agenda */ compute_goal_agenda(); /* make space in plan states info, and relax */ for ( i = 0; i < MAX_PLAN_LENGTH + 1; i++ ) { make_state( &(gplan_states[i]), gnum_ft_conn ); gplan_states[i].max_F = gnum_ft_conn; } make_state( ¤t_start, gnum_ft_conn ); current_start.max_F = gnum_ft_conn; make_state( ¤t_end, gnum_ft_conn ); current_end.max_F = gnum_ft_conn; initialize_relax(); source_to_dest( &(gplan_states[0]), &ginitial_state ); source_to_dest( ¤t_start, &ginitial_state ); source_to_dest( ¤t_end, &(ggoal_agenda[0]) ); for ( i = 0; i < gnum_goal_agenda; i++ ) { if ( !do_enforced_hill_climbing( ¤t_start, ¤t_end ) ) { break; } source_to_dest( ¤t_start, &(gplan_states[gnum_plan_ops]) ); if ( i < gnum_goal_agenda - 1 ) { for ( j = 0; j < ggoal_agenda[i+1].num_F; j++ ) { current_end.F[current_end.num_F++] = ggoal_agenda[i+1].F[j]; } } } found_plan = ( i == gnum_goal_agenda ) ? TRUE : FALSE; if ( !found_plan ) { printf("\n\nEnforced Hill-climbing failed !"); printf("\nswitching to Best-first Search now.\n"); found_plan = do_best_first_search(); } times( &end ); TIME( gsearch_time ); if ( found_plan ) { print_plan(); } output_planner_info(); printf("\n\n"); exit( 0 ); }
int main( int argc, char *argv[] ) { /* resulting name for ops file */ char ops_file[MAX_LENGTH] = ""; /* same for fct file */ char fct_file[MAX_LENGTH] = ""; /* name for additional goal file */ char mul_file[MAX_LENGTH] = ""; struct timeb start, end; State current_start, current_end; int i, j; Bool found_plan; Bool found_plan_for_multiple_purpose; /*times ( &lstart );*/ ftime(&lstart); /* command line treatment*/ if ( argc == 1 || ( argc == 2 && *++argv[0] == '?' ) ) { ff_usage(); exit( 1 ); } if ( !process_command_line( argc, argv ) ) { ff_usage(); exit( 1 ); } /* make file names */ /* one input name missing */ if ( !gcmd_line.ops_file_name || !gcmd_line.fct_file_name || !gcmd_line.mul_file_name ) { fprintf(stdout, "\nmul-fip : three input files needed\n"); ff_usage(); exit( 1 ); } /* add path info, complete file names will be stored in * ops_file and fct_file */ sprintf(ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name); sprintf(fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name); sprintf(mul_file, "%s%s", gcmd_line.path, gcmd_line.mul_file_name); /* parse the input files */ /* start parse & instantiation timing*/ /*times( &start );*/ ftime(&start); /* domain file (ops) */ /* it is important for the pddl language to define the domain before * reading the problem */ load_ops_file( ops_file ); /* problem file (facts) */ if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: parsing problem file.\n"); } load_fct_file( fct_file ); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: original purpose fact file done.\n"); } load_mul_file( mul_file ); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: multiple purpose fact file done.\n"); } /* This is needed to get all types.*/ /* modified by jovi: adding supprot for addtional constant */ build_orig_constant_list(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: build_orig_constant_list() done.\n"); } /* last step of parsing: see if it's an ADL domain! */ if ( !make_adl_domain() ) { printf("\nmul-fip: this is not an ADL problem!"); printf("\n\tcan't be handled by this version.\n\n"); exit( 1 ); } if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: make_adl_domain() done.\n"); } /* now instantiate operators; */ /*JC: initialize the array*/ gInvActs = (StateActionPair*)calloc(MAX_INVALID_ACTIONS, sizeof(StateActionPair)); /************************** * first do PREPROCESSING * **************************/ /* start by collecting all strings and thereby encoding * the domain in integers. */ encode_domain_in_integers(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: encode_domain_in_integers() done.\n"); } /* inertia preprocessing, first step: * - collect inertia information * - split initial state into * _ arrays for individual predicates * - arrays for all static relations * - array containing non - static relations */ do_inertia_preprocessing_step_1(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: do_inertia_preprocessing_step_1() done.\n"); } /* normalize all PL1 formulae in domain description: * (goal, preconds and effect conditions) * - simplify formula * - expand quantifiers * - NOTs down */ normalize_all_wffs(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: normalize_all_wffs() done.\n"); } /* translate negative preconds: introduce symmetric new predicate * NOT-p(..) (e.g., not-in(?ob) in briefcaseworld) */ translate_negative_preconds(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: translate_negative_preconds() done.\n"); } /* split domain in easy (disjunction of conjunctive preconds) * and hard (non DNF preconds) part, to apply * different instantiation algorithms */ split_domain(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: split_domain() done.\n"); } /*********************************************** * PREPROCESSING FINISHED * * * * NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER * ***********************************************/ /*jovi: updated for multiple purpose */ build_easy_action_templates(); build_hard_action_templates(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: build_easy_action_template() done.\n"); } /*times( &end );*/ ftime(&end); TIME( gtempl_time ); /*times( &start );*/ ftime(&start); /* perform reachability analysis in terms of relaxed fixpoint */ perform_reachability_analysis(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: perform_reachability_analysis() done.\n"); } /*times( &end );*/ ftime(&end); TIME( greach_time ); /*times( &start );*/ ftime(&start); /* collect the relevant facts and build final domain * and problem representations.*/ collect_relevant_facts(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: collect_relevant_facts.\n"); } /*times( &end );*/ ftime(&end); TIME( grelev_time ); /*times( &start );*/ ftime(&start); /* now build globally accessable connectivity graph */ build_connectivity_graph(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: build_connectivity_graph().\n"); } /*times( &end );*/ ftime(&end); TIME( gconn_time ); /*********************************************************** * we are finally through with preprocessing and can worry * * bout finding a plan instead. * ***********************************************************/ ftime(&mystart); /*times( &start );*/ ftime(&start); /* another quick preprocess: approximate goal orderings and split * goal set into sequence of smaller sets, the goal agenda */ compute_goal_agenda(); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: compute_goal_agenda().\n"); } /*debugit(&ginitial_state);*/ /* make space in plan states info, and relax * make sapce is initialize the space for gplan_states and * initialzie the variable */ for ( i = 0; i < MAX_PLAN_LENGTH + 1; i++ ) { make_state( &(gplan_states[i]), gnum_ft_conn ); gplan_states[i].max_F = gnum_ft_conn; } make_state( ¤t_start, gnum_ft_conn ); current_start.max_F = gnum_ft_conn; make_state( ¤t_end, gnum_ft_conn ); current_end.max_F = gnum_ft_conn; initialize_relax(); /* need to read the agenda paper */ source_to_dest( &(gplan_states[0]), &ginitial_state ); source_to_dest( ¤t_start, &ginitial_state ); source_to_dest( ¤t_end, &(ggoal_agenda[0]) ); for ( i = 0; i < gnum_goal_agenda; i++ ) { /* JC add a hashtable creating in do_enforced_hill_climbling*/ if (!do_enforced_hill_climbing(¤t_start, ¤t_end)) { if (gcmd_line.display_info >= 1) { printf("\nDebugInfo: do_enforced_hill_climbling() exit .\n"); } break; } source_to_dest( ¤t_start, &(gplan_states[gnum_plan_ops]) ); if ( i < gnum_goal_agenda - 1 ) { for ( j = 0; j < ggoal_agenda[i+1].num_F; j++ ) { current_end.F[current_end.num_F++] = ggoal_agenda[i+1].F[j]; } } } found_plan = ( i == gnum_goal_agenda ) ? TRUE : FALSE; if ( !found_plan ) { printf("\nDebugInfo: switching to Best-first Search now.\n"); reset_ff_states(); found_plan = do_best_first_search(); } if ( gcmd_line.display_info >= 1 ) { printf("\n************************************************\n"); printf("\n* mul-fip: fip plan finished for single goal. *\n"); printf("\n************************************************\n"); } print_plan(); if ( !found_plan ) { /*print_plan();*/ /* D action add to group */ build_action_group(); gfipPlan.num_sons = 0; gfipPlan.action = -1; print_plan(); /*put the ultimate goal to the solved set*/ StateActionPair *g = new_StateActionPair(); make_state(&g->state, gnum_ft_conn); g->state.max_F = gnum_ft_conn; source_to_dest(&g->state, &ggoal_state); g->state.num_L = 1; g->state.L[0] = 10000000; /*make it the biggest*/ add_solved_state(g); /*ugly, but work*/ convert_ff_plan_to_fip_plan( &gfipPlan ); solve_unsolved_states(); if(!gsolved_states) { printf("No solutions are found! The problem is unsolvable.\n"); exit(0); } else if(g_is_strong) { StateActionPair *ptr = gsolved_states; Bool valid = FALSE; while(ptr) { if(ptr->state.num_L == 1 && ptr->state.L[0] == 1) { valid = TRUE; break; } ptr = ptr->next; } if(!valid) { printf("The initial state is a dead-end! The problem is unsolvable.\n"); exit(0); } } printf("##########################################\n"); printf("##### PROCEDURE-LIKE CODE ############\n"); printf("##########################################\n"); /* print_fip_plan_1( is_solved_state(&ginitial_state) , &gfipPlan, 1); */ /* times( &end ); */ ftime(&end); TIME( gsearch_time ); /* myend = clock(); */ ftime(&myend); /* printf("my cac is %7.3f\n", 1.0*(myend.millitm - mystart.millitm)/1000.0); */ print_fip_plan_2(); if(to_print_state) print_all_states(); /* print_fip_plan_3( &gfipPlan, 0 ); */ } printf("The total searching time is %7.3f\n", (myend.time - mystart.time) + (myend.millitm - mystart.millitm)/1000.0); output_planner_info(); /******************************************** * Multiple Purpose Planning * ********************************************/ if ( gcmd_line.display_info >= 1 ) { printf("\n************************************************\n"); printf("\n* mul-fip: multiple purpose planning *\n"); printf("\n************************************************\n"); } set_global_variables_for_multiple_purpose(); ftime(&start); update_reachability_analysis_for_multiple_purpose (); ftime(&end); TIME( gadd_reach_time ); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: update_reachability_analysis_for_multiple_purpose() finished\n"); } ftime(&start); update_relevant_facts_for_multiple_purpose (); ftime(&end); TIME( gadd_relev_time ); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: update_relevant_facts_for_multiple_purpose() finished\n"); } ftime(&start); update_connectivity_graph_for_multiple_purpose(); ftime(&end); TIME( gadd_conn_time ); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: update_connectivity_graph_for_multiple_purpose() finished\n"); } compute_goal_agenda_for_multiple_purpose (); if ( gcmd_line.display_info >= 1 ) { printf("\nDebugInfo: compute_goal_agenda_for_multiple_purpose() finished\n"); } for ( i = 0; i < MAX_PLAN_LENGTH + 1; i++ ) { make_state( &(gadd_plan_states[i]), gnum_ft_conn ); gadd_plan_states[i].max_F = gnum_ft_conn; } source_to_dest( ¤t_end, &(gadd_goal_agenda[0]) ); for ( i = 0; i < gadd_num_goal_agenda; i++ ) { /* JC add a hashtable creating in do_enforced_hill_climbling*/ if ( !do_enforced_hill_climbing_for_multiple_purpose ( ¤t_start, ¤t_end ) ) { break; } source_to_dest( ¤t_start, &(gplan_states[gnum_plan_ops]) ); if ( i < gnum_goal_agenda - 1 ) { for ( j = 0; j < ggoal_agenda[i+1].num_F; j++ ) { current_end.F[current_end.num_F++] = ggoal_agenda[i+1].F[j]; } } } found_plan_for_multiple_purpose = ( i == gadd_num_goal_agenda ) ? TRUE : FALSE; if ( !found_plan_for_multiple_purpose ) { printf("\n\nEnforced Hill-climbing failed !"); printf("\nswitching to Best-first Search now.\n"); reset_ff_states_for_multiple_purpose(); found_plan_for_multiple_purpose = do_best_first_search_for_multiple_purpose(); } if ( gcmd_line.display_info >= 1 ) { printf("\n************************************************\n"); printf("\n* mul-fip: fip plan finished for multiple goal. *\n"); printf("\n************************************************\n"); } print_plan(); if ( !found_plan_for_multiple_purpose ) { /*print_plan();*/ /* D action add to group */ build_action_group(); gfipPlan.num_sons = 0; gfipPlan.action = -1; print_plan(); /*put the ultimate goal to the solved set*/ StateActionPair *g = new_StateActionPair(); make_state(&g->state, gnum_ft_conn); g->state.max_F = gnum_ft_conn; source_to_dest(&g->state, &ggoal_state); g->state.num_L = 1; g->state.L[0] = 10000000; /*make it the biggest*/ add_solved_state(g); /*ugly, but work*/ convert_ff_plan_to_fip_plan( &gfipPlan ); solve_unsolved_states(); if(!gsolved_states) { printf("No solutions are found! The problem is unsolvable.\n"); exit(0); } else if(g_is_strong) { StateActionPair *ptr = gsolved_states; Bool valid = FALSE; while(ptr) { if(ptr->state.num_L == 1 && ptr->state.L[0] == 1) { valid = TRUE; break; } ptr = ptr->next; } if(!valid) { printf("The initial state is a dead-end! The problem is unsolvable.\n"); exit(0); } } printf("##########################################\n"); printf("##### PROCEDURE-LIKE CODE ############\n"); printf("##########################################\n"); /* print_fip_plan_1( is_solved_state(&ginitial_state) , &gfipPlan, 1); */ /* times( &end ); */ ftime(&end); TIME( gsearch_time ); /* myend = clock(); */ ftime(&myend); /* printf("my cac is %7.3f\n", 1.0*(myend.millitm - mystart.millitm)/1000.0); */ print_fip_plan_2(); if(to_print_state) print_all_states(); /* print_fip_plan_3( &gfipPlan, 0 ); */ } /*****************************************************************************************/ output_planner_info(); printf("\n\n"); exit( 0 ); }