/********************************
* EHC FUNCTION, CALLED BY MAIN *
********************************/
Bool do_weak_planning( State *start, State *end ) {
/*
printf("debug: subplanning---initial state\n");
debugit(start);
printf("\ndebug: goal state\n");
debugit(end);
printf("\n*************************\n");
debugAllSolvedState();
debugAllUnSolvedState();
*/
Bool found_plan = do_enforced_hill_climbing(start, end);
if(!found_plan){
printf("\n\nEnforced Hill-climbing failed !");
printf("\nswitching to Best-first Search now.\n");
reset_ff_states();
found_plan = do_best_first_search();
}
return found_plan;
}
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] = "";
char sol_file[MAX_LENGTH] = "";
struct tms start, end;
struct timeval tv;
struct timezone tz;
State current_start, current_end;
int i, j, k;
Bool found_plan=0;
#ifdef __EFENCE__
extern int EF_ALLOW_MALLOC_0;
EF_ALLOW_MALLOC_0 = 1;
#endif
printf("#\n");
printf("# (C) Copyright 2008, University of Illinois, Urbana-Champaign\n");
printf("#\n");
printf("# All rights reserved. Use of this software is permitted ONLY for\n");
printf("# non-commercial research purposes, and it may be copied only\n");
printf("# for that use only. All copies must include this copyright message.\n");
printf("# This software is made available AS IS, and neither the authors\n");
printf("# nor the University of Illinois, make any warranty about the\n");
printf("# software or its performance.\n");
printf("#\n");
dis_gcmd_line.display_info = 1;
dis_gcmd_line.debug = 0;
dis_gcmd_line.ehc = dis_TRUE;
dis_gcmd_line.optimize = dis_FALSE;
dis_gcmd_line.g_weight = 1;
dis_gcmd_line.h_weight = 1;
SymmLagrangian = 0;
SymmLagrange = 0;
GpG.subsolver = 0;
//dis_processdis__command_line(argc, argv);
/*
printf("dis_gcmd_line.g_weight = %d\n", dis_gcmd_line.g_weight );
printf("dis_gcmd_line.h_weight = %d\n", dis_gcmd_line.h_weight );
printf("dis_gcmd_line.ehc = %d\n", dis_gcmd_line.ehc );
printf("dis_gcmd_line.optimize = %d\n", dis_gcmd_line.optimize );
printf("dis_gcmd_line.display_info = %d\n", dis_gcmd_line.display_info );
printf("dis_gcmd_line.debug = %d\n", dis_gcmd_line.debug );
*/
//-------
so_signal_management();
strcpy (gcomm_line, "");
for (i = 0; i < argc; i++)
{
strcat (gcomm_line, argv[i]);
strcat (gcomm_line, " ");
}
get_path (*argv, glpg_path);
initialize_preset_values ();
#ifdef __STATISTIC_LM__
init_statistic();
#endif
/*Reset hash-table
*/
reset_cvar_hash_table();
/* Initialize random seed
*/
gettimeofday (&tv, &tz);
seed = ((tv.tv_sec & 0177) * 1000000) + tv.tv_usec;
/* command line treatment
*/
if (argc == 1 || (argc == 2 && *++argv[0] == '?'))
{
lpg_usage ();
exit (1);
}
gcmd_line.out_file_name[0] = 0;
if (!process_command_line (argc, argv))
{
lpg_usage ();
exit (1);
}
/* make file names
*/
/* one input name missing
*/
if (!gcmd_line.ops_file_name || !gcmd_line.fct_file_name)
{
fprintf (stdout, "\n%s: two input files needed\n\n", NAMEPRG);
lpg_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);
strcpy (gops_file, ops_file);
strcpy (gfct_file, fct_file);
sprintf (sol_file, "%s%s", gcmd_line.path, gcmd_line.sol_file_name);
/* parse the input files
*/
/* start parse & instantiation timing
*/
times (&glob_start_time);
times (&start);
/*
//GpG.feed_MFF_LPG = TRUE;
GpG.feed_MFF_LPG = FALSE;
if(GpG.feed_MFF_LPG) {
dis_MFF_main(ops_file, fct_file);
mff_to_lpg();
}
else
// START OF PARSING
{*/
/* domain file (ops)
*/
// ADL?
GpG.gis_ADL = ADL_ops_file(ops_file);
i = get_requirements(ops_file);
if((!GpG.is_deripred || i == 1 || !GpG.gis_ADL) && !GpG.is_goal_utilities && !GpG.is_action_costs) {
if(!i || !GpG.gis_ADL) {
printf ("\nParsing domain file\n");
fflush(stdout);
/* it is important for the pddl language to define the domain before
* reading the problem
*/
load_ops_file (ops_file);
// Y. Chen
if(gloaded_dps) {
// printf("\nSGPlan: Contains derived predicates\n");
GpG.is_deripred = TRUE;
}
else {
// printf("\nSGPlan: No derived predicates\n");
GpG.is_deripred = FALSE;
}
}
else
{
gdomain_name = dis_copy_dis_Token("PSR");
GpG.is_deripred = TRUE;
}
}
/* ============= Search Modal =======================
* Y. Chen
* Decide which parser to use here
*/
search_ops_modal();
//fprintf(stderr, "\nSearchModal = %d %d\n", GpG.SearchModal, GpG.SecondaryModal);
// MFF_parser
if((GpG.SearchModal == 5) || (GpG.SearchModal == 7)
|| (GpG.SearchModal == 6) || (GpG.SearchModal == 100)
|| (GpG.SearchModal == 104) || (GpG.SearchModal == 106)
|| (GpG.SearchModal == 107)
|| (GpG.SearchModal == -1) || (GpG.SearchModal <= -1000)) {
/*
Settlers 5
Sattelite 6 Sattelite TIME_TIMEWINDOWS_COMPILED 106
UMTS 7
Psr large 100 Psr middle-compiled 104
Promela OPTICAL_TELEGRAPH_FLUENTS PHILOSOPHERS_FLUENTS 107
*/
GpG.MFF_parser = TRUE;
} else {
GpG.MFF_parser = FALSE;
}
// ComputeMutex
if(((GpG.SearchModal == 0)||(GpG.SearchModal == 105))
|| (GpG.SearchModal == 3 && GpG.is_til )
) {
/*
Airport 0 Airport TEMPORAL_TIMEWINDOWS_COMPILED 105
Pipesworld NOTANKAGE_TEMPORAL_DEADLINES 3
*/
GpG.lowmemory = FALSE;
ComputeMutex = TRUE;
} else {
ComputeMutex = FALSE;
}
if(GpG.is_deripred) {
ComputeMutex = FALSE;
}
/* ==================================================*/
if(GpG.MFF_parser) {
mffDistributedSearch(ops_file, fct_file);
exit(0);
}
/* ===================================================
*/
transfer_PlDP_PlOperator();
/*dirty trick to get another copy of gloaded_ops */
if (GpG.is_til)
load_fct_file (fct_file);
gloaded_pl2ops = gloaded_ops;
gloaded_ops = NULL;
/* derived predicates */
gloaded_dps = NULL;
/* timed initial literals */
gnum_tils = 0;
g_tils = gtils = NULL;
gdomain_name = NULL;
gorig_initial_facts = NULL;
gorig_goal_facts = NULL;
gmetric_exp = NULL;
gloaded_axioms = NULL;
gparse_types = NULL;
gparse_constants = NULL;
gparse_predicates = NULL;
gparse_functions = NULL;
gparse_objects = NULL;
gorig_constant_list = NULL;
gpredicates_and_types = NULL;
gfunctions_and_types = NULL;
gloaded_constraints = NULL;
gloaded_preferences = NULL;
load_ops_file (ops_file);
// Y. Chen
transfer_PlDP_PlOperator();
/*add dummy effect to operators without boolean effects */
add_dummy_effects (gloaded_ops);
add_dummy_effects (gloaded_pl2ops);
/*counts numeric preconds and effects */
count_num_preconds_and_effects ();
GpG.gplan_actions = NULL;
/* problem file (facts)
*/
if (gcmd_line.display_info >= 1)
{
printf ("\nParsing problem file\n");
fflush(stdout);
}
load_fct_file (fct_file);
if (gcmd_line.display_info >= 1)
printf ("\n\n");
allocate_after_parser();
/* now we have PlOperators and PlNodes */
reduce_pddl2_to_pddl1 ();
/* 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 ("\n%s: this is an ADL problem!", NAMEPRG);
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);
check_time_and_length (0);
// Y.Chen
seed = 2004;
srandom(seed);
#ifdef __MY_OUTPUT__
printf ("\n Seed %d \n", seed);
#endif
/* perform reachability analysis in terms of relaxed
* fixpoint
*/
perform_reachability_analysis ();
times (&end);
TIME (greach_time);
times (&start);
check_time_and_length (0);
/* collect the relevant facts and build final domain
* and problem representations.
*/
collect_relevant_facts ();
times (&end);
TIME (grelev_time);
times (&start);
check_time_and_length (0);
/* now build globally accessable connectivity graph
*/
build_connectivity_graph ();
/*
}// END PARSING
*/
// Y. Chen
set_DPop_flag();
if(GpG.SearchModal != 3 && GpG.SearchModal != -2) {
if(!ComputeMutex) {
DistributeSearch(&ginitial_state, &ggoal_state, &subplan_actions);
exit(0);
}
}
times (&end);
TIME (gconn_time);
times (&start);
check_time_and_length (0);
/* association to gef_conn[i] a corresponding complet ploperator */
associate_PlOperator_with_EfConn ();
/* adding composed numeric quantities */
add_composite_vars ();
make_numgoal_state(GpG.numeric_goal_PlNode);
/* make false the comparison between uninitialized numeric quantities */
make_false_all_checks_on_not_init ();
/* Semplification for inertial vars
*/
propagate_inertias ();
if (GpG.SearchModal == -2)
{
mffDistributedSearch(ops_file, fct_file);
exit(0);
}
if(GpG.SearchModal == 3) {
if(!ComputeMutex) {
DistributeSearch(&ginitial_state, &ggoal_state, &subplan_actions);
exit(0);
}
}
if (DEBUG0)
if (GpG.non_strips_domain)
{
/*
if (GpG.variable_duration)
printf ("\n\nAction durations have been computed\n");
else
printf ("\n\nThere is no action duration to compute\n");*/
}
/* Set vars orig_weight_cost and orig_weight_time according with plan evaluation metric
*/
if (goptimization_exp != -1)
set_cost_and_time_coeffs ();
/*
if (DEBUG0)
printf("\nEvaluation function weights:\n Action duration %.2f; Action cost %.2f", GpG.orig_weight_time, GpG.orig_weight_cost);
if (DEBUG0)
printf ("\n\nTemporal flag: %s\n", GpG.temporal_plan ? "ON" : "OFF");
*/
/* Make numeric effects structure
*/
create_descnumeff_of_efconns ();
/* Sets flag is_numeric for each action (efconn)
*/
set_numeric_flag ();
assert (gnum_comp_var < MAX_NUM_VALUE);
/* Copy initial state in initial_state
*/
for (i = 0; i < gnum_comp_var; i++)
ginitial_state.V[i] = GCOMP_VAR_VALUE(i);
times (&end);
TIME (gnum_time);
times (&start);
/* Print information about action istantiation
*/
print_parser_info_for_debug();
//print_real_state(ginitial_state);
if(ComputeMutex) {
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if (1) {
if (DEBUG0 && !DEBUG1) {
// printf ("\nComputing mutex... ");
// fflush (stdout);
}
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN FACTS ---\n");
if (GpG.accurate_cost >= 1)
allocate_reachability_information_data();
/* Comute mutex between facts
*/
calc_mutex (&ginitial_state);
if (!are_goal_reachable_and_non_mutex ()) {
printf ("\nThe problem is unsolvable since at the fixpoint level the goals are mutex or not reachable\n\n");
exit (0);
}
}
times (&end);
TIME (gmutex_ft_time);
if (DEBUG2)
printf ("\n");
if (DEBUG1)
printf ("\n --> Compute mutex between facts TOTAL TIME: %12.2f",gmutex_ft_time);
times (&start);
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if(1){
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN ACTIONS ---\n");
/*Compute action-action, action_fact, fact-action mutex
*/
calc_mutex_ops ();
}
times (&end);
TIME (gmutex_ops_time);
if (DEBUG1)
printf ("\n --> Compute mutex between actions TOTAL TIME: %12.2f\n",gmutex_ops_time);
times (&start);
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if(1){
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN NUMERIC FACTS ---\n");
/* Compute mutex between action with numeric effects
*/
if (!GpG.lowmemory)
calc_mutex_num_efs ();
}
times (&end);
TIME (gmutex_num_time);
if (DEBUG1)
printf("\n --> Compute mutex between numeric facts TOTAL TIME: %12.2f\n",gmutex_num_time);
if (DEBUG2)
print_mutex_result ();
if (DEBUG0 && !DEBUG1) {
// printf ("done");
// fflush (stdout);
}
times (&start);
//if (DEBUG6 && !GpG.lowmemory)
print_matrs ();
gmutex_total_time = gmutex_ft_time + gmutex_ops_time + gmutex_num_time;
}
if (strlen (gcmd_line.sol_file_name) > 0)
load_pddl2_plan (sol_file, &GpG.gplan_actions, 0);
if (GpG.SearchModal == 3)
ComputeMutex = FALSE;
GpG.max_num_actions = gnum_ef_conn;
GpG.max_num_facts = gnum_ft_conn;
GpG.max_num_ft_block = gnum_ft_block;
/***********************************************************
* we are finally through with preprocessing and can worry *
* about finding a plan instead. *
***********************************************************/
/* another quick preprocess: approximate goal orderings and split
* goal set into sequence of smaller sets, the goal agenda
*/
// Yixin
if(ComputeMutex) {
modify_ft_ef_mutex();
compute_goal_agenda();
}
// printf ("******************\n");
/*
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;
*/
source_to_dest (&(gplan_states[0]), &ginitial_state);
source_to_dest (¤t_start, &ginitial_state);
source_to_dest (¤t_end, &ggoal_state);
remove_unappliable_actions ();
if ((GpG.search_type == LOCAL && GpG.numrun > 0 && GpG.numtry > 0) ||
GpG.search_type == DIS_SEARCH )
{
k = MAX (GpG.input_plan_lenght, gmutex_level);
for (i = 0; i < k; i++)
{
if (i < gmutex_level)
create_vectlevel (0);
else
create_vectlevel (1);
}
allocate_data_for_local_search();
create_all_min_array ();
GpG.fixpoint_plan_length = GpG.max_plan_length - 1;
GpG.saved_fixpoint_plan_length = GpG.fixpoint_plan_length ;
GpG.curr_goal_state = ¤t_end;
}
if (DEBUG1) {
printf ("\n\nTime spent for preprocessing:");
printf ("\n Instantiating: %7.2f seconds", gtempl_time + greach_time + grelev_time + gconn_time + gsearch_time);
printf ("\n Mutex relations: %7.2f seconds", gmutex_total_time);
printf ("\n Numeric relations: %7.2f seconds", gnum_time);
}
if (DEBUG0) {
times (&glob_end_time);
gtotal_time = (float) ((glob_end_time.tms_utime - glob_start_time.tms_utime + glob_end_time.tms_stime - glob_start_time.tms_stime) / 100.0);
// printf ("\nPreprocessing total time: %.2f seconds",gtotal_time);
}
/*
printf ("\n\ninitial state is:\n\n");
for (i = 0; i < ginitial_state.num_F; i++)
{
print_ft_name (current_start.F[i]);
printf ("\n");
}
printf ("\n\ngoal state is:\n\n");
for (i = 0; i < current_end.num_F; i++)
{
print_ft_name (current_end.F[i]);
printf ("\n");
}
printf("GpG.fixpoint_plan_length = ",
GpG.fixpoint_plan_length);
*/
#ifdef __TEST__
for (i = 0; i < gnum_op_conn; i++)
{
print_op_name(i);
printf(" -- %f \n", get_action_cost (i));
}
#endif
if (GpG.do_best_first == TRUE && GpG.numrun==0)
GpG.search_type=BEST_FIRST;
/* Search untill it is not reached termination condition (given by the function 'is_term_condition_reached')
*/
while(!is_terminated)
{
/* Different types of local search
*/
switch(GpG.search_type)
{
/* Local Search usually used in LPG
*/
case DIS_SEARCH:
DistributeSearch(¤t_start, ¤t_end, &subplan_actions);
GpG.gplan_actions = subplan_actions;
subplan_actions = NULL;
is_terminated=TRUE;
break;
case LOCAL:
/* Do Local Search
*/
LocalSearch (¤t_start, ¤t_end, &subplan_actions);
/* Store plan in GpG.gplan_actions
*/
GpG.gplan_actions = subplan_actions;
subplan_actions = NULL;
/* Control if the termination condition is reached
*/
is_terminated=TRUE;
//is_terminated= is_term_condition_reached();
break;
/* Best First Search implemented by J. Hoffmann (FF-v2.3)
*/
case BEST_FIRST:
// strips_gef_conn();
// load_ff_gef_conn();
if (DEBUG0)
printf("\n\nSwitching to Best-first Search ( code from J. Hoffmann's package FF-v2.3 ) \n");
check_time_and_length (0); /* con zero non controlla la lunghezza */
/* Return solution if reached, FALSE otherwise
*/
found_plan = do_best_first_search ();
printf("do_best_first_search");
//if (do_enforced_hill_climbing (¤t_start, ¤t_end))
//printf("do_hill");
times (&end);
TIME (gsearch_time);
times (&end);
times (&glob_end_time);
gtotal_time = (float) ((glob_end_time.tms_utime - glob_start_time.tms_utime + glob_end_time.tms_stime - glob_start_time.tms_stime) / 100.0);
/* If a solution was found in best first search print solution
*/
if (found_plan)
{
#ifdef __MY_OUTPUT__
printf ("\nFFGGHH::%.2f::%d\n", gtotal_time, gnum_plan_ops);
#endif
store_adapted_temporal_plan_ff (gcmd_line.fct_file_name);
printf ("\nTotal time: %.2f\nSearch time: %.2f\nActions: %d\nExecution cost: %.2f\nDuration: %.3f\nPlan quality: %.3f", gtotal_time, gsearch_time, GpG.num_actions, GpG.total_cost, GpG.total_time,GpG.total_cost * GpG.orig_weight_cost + GpG.total_time * GpG.orig_weight_time);
printf ("\n Plan file:");
printf (" plan_bestfirst_%s.SOL", gcmd_line.fct_file_name);
}
if (DEBUG1)
output_planner_info ();
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
/* Hill Climbing Search
*/
case HILL_CLIMBING:
if (do_enforced_hill_climbing (¤t_start, ¤t_end))
source_to_dest (¤t_start, &(gplan_states[gnum_plan_ops]));
printf("do_hill");
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
default:
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
}
if (DEBUG2)
{
printf ("\n\nInitial state is:\n\n");
for (j = 0; j < ginitial_state.num_F; j++)
{
print_ft_name (current_start.F[j]);
printf ("\n");
}
printf ("\n\nGoal state is:\n\n");
for (j = 0; j < current_end.num_F; j++)
{
print_ft_name (current_end.F[j]);
printf ("\n");
}
}
}
printf ("\n\n");
printf ("\nTotal time: %.3f\n", gtotal_time);
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] = "";
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 );
}