int main(int argc, char *argv[]) { FILE *in_file = NULL; /* file with data for problems */ ZOLTAN_COMM_OBJ *plan; /* communication data structure pointer */ struct Params params; /* parameters describing a problem */ struct Data data; /* data describing a problem instance */ struct Data my_send_data; /* data I initially own */ struct Answer true_answer; /* expected outcome of exchange */ int nvals_recv; /* number of vals I own after exchange */ float *recv_data; /* values I own after exchange */ float *reverse_data; /* values I own after reversing communication */ char file_name[100]; /* name of input file */ int nbytes; /* size of objects */ int my_proc; /* my processor ID */ int nprocs; /* total number of processors */ int flag; /* return code from comm operations */ int more_problems; /* are there more problems to do? */ int i, j; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &my_proc); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); Zoltan_Memory_Debug(2); if (argc > 1) strcpy(file_name, argv[1]); else strcpy(file_name,"comm_input.dat"); if (my_proc == 0) { in_file = fopen(file_name, "r"); if (in_file == NULL) { printf("No input file `%s' found.\n", file_name); } } /* Read some problem descriptors from a file */ more_problems = read_comm_problem(in_file, ¶ms, &out_level, my_proc); while (more_problems) { /* Generate full data at random on each proc */ gen_comm_data(¶ms, &data, nprocs); if (out_level > 2) if (my_proc == 0) print_data("DATA", &data); /* Figure out from the data what what to expect to receive */ extract_comm_answer(&data, &true_answer, my_proc, nprocs); /* Extract what to send */ set_up_comm_from_send(&data, &my_send_data, params.blocked, my_proc, nprocs); if (out_level > 2) print_data("MY_DATA", &my_send_data); if (out_level > 1) printf("%d: About to call comm_create\n", my_proc); /* Call comm routines */ Zoltan_Comm_Create(&plan, my_send_data.nvals, my_send_data.proc_dest, MPI_COMM_WORLD, 1, &nvals_recv); if (out_level > 1) printf("%d: About to call comm_info\n", my_proc); check_comm_info(plan, &my_send_data, nvals_recv, my_proc); if (out_level > 2) print_plan("BEFORE RESIZE", plan, my_proc); /* "4" reflects the max_sizes value in gen_comm_data */ recv_data = (float *) ZOLTAN_MALLOC(nvals_recv * 4 * sizeof(float)); reverse_data = (float *) ZOLTAN_MALLOC(my_send_data.nvals * 4 * sizeof(float)); if (my_send_data.sizes != NULL) { if (out_level > 1) printf("%d: About to call comm_resize\n", my_proc); Zoltan_Comm_Resize(plan, my_send_data.sizes, 43, NULL); Zoltan_Comm_Resize(plan, NULL, 43, NULL); Zoltan_Comm_Resize(plan, my_send_data.sizes, 43, NULL); if (out_level > 2) print_plan("AFTER RESIZE", plan, my_proc); } if (my_send_data.sizes == NULL) nbytes = my_send_data.same_size * sizeof(float); else nbytes = sizeof(float); if (out_level > 1) printf("%d: About to call comm_do\n", my_proc); flag = Zoltan_Comm_Do(plan, 2, (char *) my_send_data.vals, nbytes, (char *) recv_data); if (flag == ZOLTAN_OK) { if (out_level > 1) printf("%d: About to call check_answer\n", my_proc); /* Check answers */ check_comm_answer(&true_answer, recv_data, my_proc); } else { printf("%d: Comm_Do returned error code %d\n", my_proc, flag); } if (out_level > 1) printf("%d: About to call comm_do_reverse\n", my_proc); i = (true_answer.sizes != NULL && plan->indices_to != NULL); MPI_Allreduce(&i, &j, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); if (j == 0) flag = Zoltan_Comm_Do_Reverse(plan, 2, (char *) recv_data, nbytes, true_answer.sizes, (char *) reverse_data); else { if (my_proc == 0) printf(">> Non-blocked, variable-sized recvs not supported\n"); flag = ZOLTAN_FATAL; } if (flag == ZOLTAN_OK) { if (out_level > 1) printf("%d: About to call check_answer_reverse\n", my_proc); /* Check answers */ check_comm_answer_reverse(&my_send_data, reverse_data, my_proc); } else { if (out_level > 1) printf("%d: Comm_Do_Reverse returned error code %d\n", my_proc, flag); } /* Free up data structures */ ZOLTAN_FREE(&reverse_data); ZOLTAN_FREE(&recv_data); free_comm_data(&data, &my_send_data, &true_answer); Zoltan_Comm_Destroy(&plan); /* Read some problem descriptors from a file */ more_problems = read_comm_problem(in_file, ¶ms, &out_level, my_proc); } Zoltan_Memory_Stats(); MPI_Finalize(); return(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] = ""; 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 ); }