instantiatei.c

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

CodeOperator *transform_PlOp_to_CodeOp( PlOperator *op )

{

  FactList *f;
  int num_vars = 0;

  CodeOperator *tmp = new_CodeOperator();

  tmp->name = copy_string( op->name->item );
  tmp->number_of_real_params = op->number_of_real_params;

  for ( f = op->params; f; f = f->next ) {
    if ( num_vars == MAX_VARS ) {
      printf("\ntoo many vars. increase MAX_VARS (currently %d)\n\n",
	     MAX_VARS);
      exit( 1 );
    }
    lvar_str[num_vars] = f->item->item;
    if ( (lvar_types[num_vars] =
	  position_in_types_table( f->item->next->item )) == -1 ) {
      if ( gcmd_line.display_info ) {
	printf("\nwarning: parameter %s of op %s has unknown or empty type %s.skipping op",
	       f->item->item, tmp->name, f->item->next->item);
      }
      free_CodeOperator( tmp );
      return NULL;
    }
    tmp->var_types[tmp->num_vars++] = lvar_types[num_vars];
    num_vars++;
  }

  tmp->preconds = transform_Pl_to_Code( op->preconds, num_vars );
  tmp->conditionals = transform_Pl_to_Code( op->effects, num_vars );

  return tmp;

}



CodeNode *transform_Pl_to_Code( PlNode *p, int num_vars )

{

  CodeNode *res = NULL, *tmp;
  PlNode *nn;
  TokenList *t;
  int i, n;

  if ( !p ) {
    return NULL;
  }

  res = new_CodeNode( p->connective );

  switch ( p->connective ) {

  case ALL:
  case EX:
    if ( num_vars == MAX_VARS ) {
      printf("\ntoo many vars. increase MAX_VARS (currently %d)\n\n",
	     MAX_VARS);
      exit( 1 );
    }
    lvar_str[num_vars] = p->atom->item;
    if ( (lvar_types[num_vars] =
	  position_in_types_table( p->atom->next->item )) == -1 ) {
      if ( gcmd_line.display_info ) {
	printf("\nwarning: quantified var %s has unknown or empty type %s. simplifying...",
	       p->atom->item, p->atom->next->item);
      }
      if ( p->connective == ALL ) {
	res->connective = TRU;
	res->next = transform_Pl_to_Code( p->next, num_vars );    
	break;	
      } else {
	res->connective = FAL;
	res->next = transform_Pl_to_Code( p->next, num_vars );    
	break;	
      }
    }
    res->var = num_vars;
    res->var_type = lvar_types[num_vars];
    res->sons = transform_Pl_to_Code( p->sons, num_vars+1 );
    break;

  case ATOM:
    if ( strcmp( p->atom->item, "EQ" ) == SAME ||
	 strcmp( p->atom->item, "eq" ) == SAME ) {
      res->predicate = -1;
    } else {
      res->predicate = position_in_predicates_table( p->atom->item );
      if ( res->predicate == -1 ) {
	printf("\nundeclared predicate %s used in domain definition\n\n",
	       p->atom->item);
	exit( 1 );
      }
    }
    n = 0;
    for ( t = p->atom->next; t; t = t->next ) {
      if ( t->item[0] == '?' ) {
	for ( i=0; i<num_vars; i++ ) {
	  if ( strcmp( lvar_str[i], t->item ) == SAME ) break;
	}
	if ( i == num_vars ) {
	  printf("\nunknown variable %s in literal %s. check input files\n\n",
		 t->item, p->atom->item);
	  exit( 1 );
	}
	if ( res->predicate != -1 &&
	     !is_subtype( lvar_types[i], gpredicates_args_type[res->predicate][n] ) ) {
	  printf("\ntype of var %s doesnt match type of arg %d of predicate %s\n\n",
		 lvar_str[i], n, gpredicates_table[res->predicate]);
	  exit( 1 );
	}
	res->arguments[n] = ((-1) * i) - 1;
      } else {
	if ( (res->arguments[n] = 
	      position_in_constants_table( t->item )) == -1 ) {
	  printf("\nunknown constant %s in literal %s. check input files\n\n",
		 t->item, p->atom->item);
	  exit( 1 );
	}
      }
      n++;
    }
    if ( res->predicate == -1 ) {
      if ( n != 2 ) {
	printf("\nfound eq - predicate with %d arguments. check input files\n\n",
	       n);
	exit( 1 );
      }
    } else {
      if ( n != garity[res->predicate] ) {
	printf("\npredicate %s is declaredto have %d arguments. check input files\n\n",
	       gpredicates_table[res->predicate],
	       garity[res->predicate]);
	exit( 1 );
      }
    }
    break;
  case AND:
  case OR:
    for ( nn = p->sons; nn; nn = nn->next ) {
      tmp = transform_Pl_to_Code( nn, num_vars );
      tmp->next = res->sons;
      res->sons = tmp;
    }
    break;
  case NOT:
    res->sons = transform_Pl_to_Code( p->sons, num_vars );
    break;
  case WHEN:
    res->sons = transform_Pl_to_Code( p->sons, num_vars );
    res->sons->next = transform_Pl_to_Code( p->sons->next, num_vars );
    break;
  case TRU:
  case FAL:
    break;
  default:
    printf("\nshouldn't come here. translation of %s\n\n",
	   gconnectives[p->connective]);
  }

  return res;

}



Bool is_subtype( int t1, int t2 )

{

  Integers *in, *in2;

  for ( in = gtypes_table[t1].integers; in; in = in->next ) {
    for ( in2 = gtypes_table[t2].integers; in2; in2 = in2->next ) {
      if ( in->index == in2->index ) {
	break;
      }
    }
    if ( !in2 ) {
      return FALSE;
    }
  }

  return TRUE;

}













/*
 *  ----------------------- BUILD IMPLICIT TUPLE TABLES ----------------------------
 *
 */




int lmaxdom;








void build_predicate_tables( void )

{

  int i, j, k, size, num_sets;
  int start, end, set_size;
  CodeNode *p = gcode_initial_state, *curr;
  ArgArray set;
  Integers *in;

  char *str[] = { "INERTIA", "POSITIVE INERTIA", 
		  "NEGATIVE INERTIA", "FLUENT" };

  setup_added_deleted_info();

  if ( gcmd_line.display_info == 4 ||
       gcmd_line.display_info == 5 ) {
    printf("\npredicates info:");
    for ( i = 0; i < gpredicates_table_size; i++ ) {
      printf("\n%d --> %s (arity %d): is %s added and %s deleted (TR 122: %s)", 
	     i, 
	     gpredicates_table[i],
	     garity[i],
	     gis_added[i] ? "" : "NOT",
	     gis_deleted[i] ? "" : "NOT",
	     str[gis_added[i]*2+gis_deleted[i]]);
    }
    printf("\n\n");
  }

  for ( i=0; i<gtypes_table_size; i++ ) {
    size = 0;
    for ( in = gtypes_table[i].integers; in; in = in->next ) {
      size++;
    }
    gtype_size[i] = size;
  }

  lmaxdom = gconstants_table_size;

  for ( i=0; i<gpredicates_table_size; i++ ) {
    gone_table_size[i] = a_to_the_power_of_b( lmaxdom, garity[i] );
  }
    
  for ( i=0; i<gpredicates_table_size; i++ ) {
    num_sets = a_to_the_power_of_b( 2, garity[i] );
    size = gone_table_size[i] * num_sets;

    gtuples[i] = ( int_pointer ) calloc( size, sizeof( int ) );

    for ( j=0; j<garity[i]; j++ ) {
      set[j] = 0;
    }
    set_size = 0;
    start = 0;
    while ( TRUE ) {
      end = start + a_to_the_power_of_b( lmaxdom, set_size );
      for ( k = start; k < end; k++ ) { 
	gtuples[i][k] = 0;
      }

      set_size = increment_set( garity[i], &set );
      if ( set_size == 0 ) {
	break;
      }
      start += gone_table_size[i];
    }
  }

  if ( p ) {
    for ( curr = p->sons; curr; curr = curr->next ) {
      increment_tuples( curr );
    }
  }

  if ( gcmd_line.display_info == 101 ) {
    printf("\nTUPLE TABLES");
    for ( i=0; i<gpredicates_table_size; i++ ) {
      printf("\nPREDICATE %s", gpredicates_table[i]);

      for ( j=0; j<garity[i]; j++ ) {
	set[j] = 0;
      }
      set_size = 0;
      start = 0;
      while ( TRUE ) {
	printf("\nTable to set: ");
	for ( j = 0; j < garity[i]; j++ ) {
	  printf(" %d", set[j]);
	}
	end = start + a_to_the_power_of_b( lmaxdom, set_size );
	for ( k = start; k < end; k++ ) { 
	  printf("\n%d", gtuples[i][k]);
	}
	
	set_size = increment_set( garity[i], &set );
	if ( set_size == 0 ) {
	  break;
	}
	start += gone_table_size[i];
      }
    }
  }

}



void setup_added_deleted_info( void )

{

  CodeOperator *i;
  CodeNode *j, *k;
  int l;

  for ( l = 0; l < MAX_PREDICATES_TABLE; l++ ) {
    gis_added[l] = FALSE;
    gis_deleted[l] = FALSE;
  }

  for ( i = gcode_operators; i; i = i->next ) {
    for ( j = i->conditionals->sons; j; j = j->next ) {
      for ( k = j; k; k = k->sons ) {
	if ( k->connective == WHEN ) {
	  break;
	}
      }
      extract_added_deleted_info( k->sons->next );
    }
  }

}



void extract_added_deleted_info( CodeNode *n )

{

  CodeNode *i;

  for ( i = n->sons; i; i = i->next ) {
    if ( i->connective == NOT ) {
      gis_deleted[i->sons->predicate] = TRUE;
    } else {
      gis_added[i->predicate] = TRUE;
    }
  }

}



void increment_tuples( CodeNode *n )

{

  int a = n->predicate;
  int set_size;
  int j, basis, adr;
  ArgArray set;

  for ( j=0; j<garity[a]; j++ ) {
    set[j] = 0;
  }
  set_size = 0;
  basis = 0;
  while ( TRUE ) {
    adr = basis +
      inner_table_adr_sethelper( garity[a], set, n->arguments );
    gtuples[a][adr]++;

    set_size = increment_set( garity[a], &set );
    if ( set_size == 0 ) {
      break;
    }
    basis += gone_table_size[a];
  }

}



Bool possibly_positive( int predicate, ArgArray arguments )

{

  int adr;

  if ( gis_added[predicate] ) {
    return TRUE;
  }

  adr = set_number( garity[predicate], arguments ) * gone_table_size[predicate];
  adr += inner_table_adr( garity[predicate], arguments );

  if ( gtuples[predicate][adr] > 0 ) {
    return TRUE;
  } else {
    return FALSE;
  }
    
}



Bool possibly_negative( int predicate, ArgArray arguments )

{

  int adr;

  if ( gis_deleted[predicate] ) {
    return TRUE;
  }

  adr = set_number( garity[predicate], arguments ) * gone_table_size[predicate];
  adr += inner_table_adr( garity[predicate], arguments );

  if ( gtuples[predicate][adr] < 
       max_unifying_tuples( predicate, arguments ) ) {
    return TRUE;
  } else {
    return FALSE;
  }

}



int a_to_the_power_of_b( int a, int b )

{

  int r = 1, i;
  
  for ( i = 0; i < b; i++ ) {
    r *= a;
  }

  return r;

}



int increment_set( int n, ArgArray *set )

{

  int r = 0, i;

  for ( i = 0; i < n; i++ ) {
    if ( (*set)[i] == 0 ) {
      (*set)[i] = 1;
      break;
    }
    (*set)[i] = 0;
  }

  for ( ; i < n; i++ ) {
    if ( (*set)[i] == 1 ) {
      r++;
    }
  }

  return r;

}



int inner_table_adr_sethelper( int n, ArgArray set, ArgArray args )

{

  int i, r, value;

  i = 0;
  value = 1;
  r = 0;
  while ( i < n ) {
    if ( set[i] == 1 ) {
      r += args[i] * value;
      value *= lmaxdom;
    }
    i++;
  }

  return r;

}



int inner_table_adr( int n, ArgArray args )

{

  int i, r, value;

  i = 0;
  value = 1;
  r = 0;
  while ( i < n ) {
    if ( args[i] >= 0 ) {
      r += args[i] * value;
      value *= lmaxdom;
    }
    i++;
  }

  return r;

}



int set_number( int n, ArgArray args )

{

  int r, i, value;

  r = 0;