instantiateiv.c

intel ipp4.1性能库的一些例子。

    free_CodeOperator( j );
  }

}



void generate_ini_goal_bitmap_representation( void )

{

  FactInfo *tpos = new_FactInfo();
  FactInfo *tneg = new_FactInfo();
  CodeNode *i, *l;
  int j;
  RelevantFact *tmp;
  BitOperator *tmpop;

  /* goal state is non trivial, otherwise we would have stopped already.
   */
  dnf( gcode_goal_state );
  if ( gcode_goal_state->connective != OR ) {
    if ( gcode_goal_state->connective != AND ) {
      if ( gcode_goal_state->connective == NOT ) {
	make_entry_in_FactInfo( &tneg, gcode_goal_state->sons->var );
      } else {
	make_entry_in_FactInfo( &tpos, gcode_goal_state->var );
      }
    } else {
      for ( i = gcode_goal_state->sons; i; i = i->next ) {
	if ( i->connective == NOT ) {
	  make_entry_in_FactInfo( &tneg, i->sons->var );
	} else {
	  make_entry_in_FactInfo( &tpos, i->var );
	}
      }
    }
  } else {
    /* disjunctive goals! introduce new GOAL-REACHED fact
     */
    if ( gpredicates_table_size == MAX_PREDICATES_TABLE ) {
      printf("\ntoo many predicates! increase MAX_PREDICATES_TABLE (currently %d)\n\n",
	     MAX_PREDICATES_TABLE);
      exit( 1 );
    }
    gpredicates_table[gpredicates_table_size] = ggoal_reached_name;
    garity[gpredicates_table_size] = 0;
    gpredicates_table_size++;
    if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
      printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n",
	     MAX_RELEVANT_FACTS);
      exit( 1 );
    }
    tmp = new_RelevantFact( NULL );
    tmp->predicate = gpredicates_table_size - 1;
    grelevant_facts[gnum_relevant_facts++] = tmp;
    /* adjust the vector length to additional fact
     */
    gft_vector_length = ( ( int ) gnum_relevant_facts / gcword_size );
    if ( ( gnum_relevant_facts % gcword_size ) > 0 ) gft_vector_length++;

    /* now make an operator for each disjunkt
     */
    for ( i = gcode_goal_state->sons; i; i = i->next ) {
      tmpop = new_BitOperator( ggoal_reached_name );
      tmpop->num_vars = 0;
      if ( i->connective != AND ) {
	if ( i->connective == NOT ) {
	  make_entry_in_FactInfo( &(tmpop->n_preconds), i->sons->var );
	} else {
	  make_entry_in_FactInfo( &(tmpop->p_preconds), i->var );
	}
      } else {
	for ( l = i->sons; l; l = l->next ) {
	  if ( l->connective == NOT ) {
	    make_entry_in_FactInfo( &(tmpop->n_preconds), l->sons->var );
	  } else {
	    make_entry_in_FactInfo( &(tmpop->p_preconds), l->var );
	  }
	}
      }
      tmpop->unconditional = new_effect();
      make_entry_in_FactInfo( &(tmpop->unconditional->p_effects), gnum_relevant_facts-1 );
      tmpop->next = gbit_operators;
      gbit_operators = tmpop;
      gnum_bit_operators++;
      if ( gcmd_line.display_info == 103 ) {      
	printf("\ngoal disjunct operator reads as follows:");
	print_BitOperator( gbit_operators );
      }
    }

    /* finally, we make sure that our only goal is to achieve
     * the new GOAL-REACHED fact
     */
    make_entry_in_FactInfo( &tpos, gnum_relevant_facts-1 );
  }
  gbit_goal_state = new_fact_info_pair( tpos, tneg );



  tpos = new_FactInfo();
  tneg = new_FactInfo();

  /* initial state can be empty, or simplified to TRU
   */
  if ( gcode_initial_state &&
       gcode_initial_state->connective != TRU ) {
    if ( gcode_initial_state->connective != AND ) {
      make_entry_in_FactInfo( &tpos, gcode_initial_state->var );
    } else {
      for ( i = gcode_initial_state->sons; i; i = i->next ) {
	make_entry_in_FactInfo( &tpos, i->var );
      }
    }
  }
  for ( j = 0; j<gnum_relevant_facts; j++ ) {
    if ( !get_bit( tpos->vector, gft_vector_length, j ) ) {
      make_entry_in_FactInfo( &tneg, j );
    }
  }
  gbit_initial_state = new_fact_info_pair( tpos, tneg );

  if ( gcmd_line.display_info == 103 ) {
    printf("\nbit coded initial state reads:");
    printf("\npositive");
    print_FactInfo( gbit_initial_state->positive );
    printf("\nnegative");
    print_FactInfo( gbit_initial_state->negative );
    printf("\nbit coded goal state reads:");
    printf("\npositive");
    print_FactInfo( gbit_goal_state->positive );
    printf("\nnegative");
    print_FactInfo( gbit_goal_state->negative );
  }

}




int get_bit( BitVector *vec, int vec_len, int pos )

{

  return (vec[pos / gcword_size] & (1 << (pos % gcword_size)));

}



void generate_BitOperators( CodeOperator *op )

{

  int i, mm;
  BitOperator *tmp, *tmp2;
  CodeNode *n, *j, *k, *l;
  Effect *tef, *ttt;

  tmp = new_BitOperator( op->name );
  tmp->num_vars = op->num_vars;
  for ( i=0; i<MAX_VARS; i++ ) {
    tmp->inst_table[i] = op->inst_table[i];
  }

  if ( op->conditionals ) {
    for ( j = op->conditionals->sons; j; j = j->next ) {
      if ( !(j->sons) ||
	   j->sons->connective == TRU ) {
	if ( !(tmp->unconditional) ) {
	  tmp->unconditional = new_Effect();
	}
	make_effect_entries( &(tmp->unconditional), j->sons->next );
	continue;
      }
      dnf( j->sons );
      if ( j->sons->connective != OR ) {
	tef = new_Effect();
	if ( j->sons->connective != AND ) {
	  if ( j->sons->connective == NOT ) {
	    make_entry_in_FactInfo( &(tef->n_conds), j->sons->sons->var );
	  } else {
	    make_entry_in_FactInfo( &(tef->p_conds), j->sons->var );
	  }
	} else {
	  for ( k = j->sons->sons; k; k = k->next ) {
	    if ( k->connective == NOT ) {
	      make_entry_in_FactInfo( &(tef->n_conds), k->sons->var );
	    } else {
	      make_entry_in_FactInfo( &(tef->p_conds), k->var );
	    }
	  }
	}
	/* conditions finished; see wether we got that already
	 */
	for ( ttt = tmp->conditionals; ttt; ttt = ttt->next ) {
	  for ( mm = 0; mm < gft_vector_length; mm++ ) {
	    if ( ttt->p_conds->vector[mm] != tef->p_conds->vector[mm] ) {
	      break;
	    }
	  }
	  if ( mm < gft_vector_length ) {
	    continue;
	  }
	  for ( mm = 0; mm < gft_vector_length; mm++ ) {
	    if ( ttt->n_conds->vector[mm] != tef->n_conds->vector[mm] ) {
	      break;
	    }
	  }
	  if ( mm < gft_vector_length ) {
	    continue;
	  }
	  free_effect( tef );
	  make_effect_entries( &ttt, j->sons->next );
	  break;
	}
	if ( ttt ) {
	  continue;
	}
	make_effect_entries( &tef, j->sons->next );
	tef->next = tmp->conditionals;
	tmp->conditionals = tef;
	continue;/* finished with effect whose conds where != OR */
      }
      for ( k = j->sons->sons; k; k = k->next ) {
	tef = new_Effect();
	if ( k->connective != AND ) {
	  if ( k->connective == NOT ) {
	    make_entry_in_FactInfo( &(tef->n_conds), k->sons->var );
	  } else {
	    make_entry_in_FactInfo( &(tef->p_conds), k->var );
	  }
	} else {
	  for ( l = k->sons; l; l = l->next ) {
	    if ( l->connective == NOT ) {
	      make_entry_in_FactInfo( &(tef->n_conds), l->sons->var );
	    } else {
	      make_entry_in_FactInfo( &(tef->p_conds), l->var );
	    }
	  }
	}
	/* conditions finished; see wether we got that already
	 */
	for ( ttt = tmp->conditionals; ttt; ttt = ttt->next ) {
	  for ( mm = 0; mm < gft_vector_length; mm++ ) {
	    if ( ttt->p_conds->vector[mm] != tef->p_conds->vector[mm] ) {
	      break;
	    }
	  }
	  if ( mm < gft_vector_length ) {
	    continue;
	  }
	  for ( mm = 0; mm < gft_vector_length; mm++ ) {
	    if ( ttt->n_conds->vector[mm] != tef->n_conds->vector[mm] ) {
	      break;
	    }
	  }
	  if ( mm < gft_vector_length ) {
	    continue;
	  }
	  free_effect( tef );
	  make_effect_entries( &ttt, j->sons->next );
	  break;
	}
	if ( ttt ) {
	  continue;
	}
	/* a bit INEFFICIENT... could also do effect entries only one time
	 * and then copy that for each disjunct
	 */
	make_effect_entries( &tef, j->sons->next );
	tef->next = tmp->conditionals;
	tmp->conditionals = tef;
      }
    }
    /* identical effects are now completely merged
     */
  }


  /* check if the overall merged unconditional effects are contradictory
   */
  if ( tmp->unconditional ) {
    for ( i = 0; i < gft_vector_length; i++ ) {
      if ( tmp->unconditional->p_effects->vector[i] &
	   tmp->unconditional->n_effects->vector[i] ) {
	return;
      }
    }
  }


  if ( !op->preconds ||
       op->preconds->connective == TRU ) {
    tmp->next = gbit_operators;
    gbit_operators = tmp;
    gnum_bit_operators++;

    if ( gcmd_line.display_info == 103 ) {
      printf("\nbit mapped operator reads as follows:");
      print_BitOperator( gbit_operators );
    }

    return;
  }

  dnf( op->preconds );
  n = op->preconds;
  if ( n->connective != OR ) {
    if ( n->connective != AND ) {
      if ( n->connective == NOT ) {
	make_entry_in_FactInfo( &(tmp->n_preconds), n->sons->var );
      } else {
	make_entry_in_FactInfo( &(tmp->p_preconds), n->var );
      }
    } else {
      for ( k = n->sons; k; k = k->next ) {
	if ( k->connective == NOT ) {
	  make_entry_in_FactInfo( &(tmp->n_preconds), k->sons->var );
	} else {
	  make_entry_in_FactInfo( &(tmp->p_preconds), k->var );
	}
      }
    }
    tmp->next = gbit_operators;
    gbit_operators = tmp;
    gnum_bit_operators++;

    if ( gcmd_line.display_info == 103 ) {
      printf("\nbit mapped operator reads as follows:");
      print_BitOperator( gbit_operators );
    }

    return;
  }

  for ( k = n->sons; k; k = k->next ) {
    tmp2 = new_BitOperator( op->name );
    tmp2->num_vars = op->num_vars;
    for ( i=0; i<MAX_VARS; i++ ) {
      tmp2->inst_table[i] = op->inst_table[i];
    }
    tmp2->unconditional = copy_effects( tmp->unconditional );
    tmp2->conditionals = copy_effects( tmp->conditionals );
    if ( k->connective != AND ) {
      if ( k->connective == NOT ) {
	make_entry_in_FactInfo( &(tmp2->n_preconds), k->sons->var );
      } else {
	make_entry_in_FactInfo( &(tmp2->p_preconds), k->var );
      }
    } else {
      for ( l = k->sons; l; l = l->next ) {
	if ( l->connective == NOT ) {
	  make_entry_in_FactInfo( &(tmp2->n_preconds), l->sons->var );
	} else {
	  make_entry_in_FactInfo( &(tmp2->p_preconds), l->var );
	}
      }
    }
    tmp2->next = gbit_operators;
    gbit_operators = tmp2;
    gnum_bit_operators++;

    if ( gcmd_line.display_info == 103 ) {
      printf("\nbit mapped operator reads as follows:");
      print_BitOperator( gbit_operators );
    }
  }
  free_BitOperator( tmp );

}



void make_entry_in_FactInfo( FactInfo **f, int index )

{

  int uid_block;
  unsigned int uid_mask;
  Integers *i;

  if ( index < 0 ) {
    /* can happen in effects: facts that are deleted, but not contained
     * in the initial state and never added.
     */
    return;
  }

  uid_block = index / gcword_size;
  uid_mask = 1 << ( index % gcword_size );
  i = new_integers( index );

  (*f)->vector[uid_block] |= uid_mask;
  i->next = (*f)->indices;
  (*f)->indices = i;

}



void make_effect_entries( Effect **e, CodeNode *n )

{

  CodeNode *j;

  if ( n->connective != AND ) {
    if ( n->connective == NOT ) {
      make_entry_in_FactInfo( &((*e)->n_effects), n->sons->var );
    } else {
      make_entry_in_FactInfo( &((*e)->p_effects), n->var );
    }
  } else {
    for ( j=n->sons; j; j = j->next ) {
      if ( j->connective == NOT ) {
	make_entry_in_FactInfo( &((*e)->n_effects), j->sons->var );
      } else {
	make_entry_in_FactInfo( &((*e)->p_effects), j->var );
      }
    }
  }

}