output.c

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

/**********************************************************************
 *
 *********************************************************************/
void
print_plops(PlOperator * plop)
{
  PlOperator * i_plop;
  int count = 0;

  if (NULL == plop) 
    {
      fprintf(stdout,"none\n");
    }

  for ( i_plop = plop; i_plop!=NULL; i_plop = i_plop->next )
    {
      fprintf(stdout,"\nOPERATOR ");
      print_hidden_tokenlist(i_plop->name, " ");
      fprintf(stdout,"\nparameters:\n");
      print_factlist ( i_plop->params, "\n", " : ");
      fprintf(stdout,"\n\npreconditions:\n");
      print_plnode(i_plop->preconds, 0);
      fprintf(stdout,"effects:\n");
      print_plnode(i_plop->effects, 0);
      fprintf(stdout,"\n-----\n");
      count++;
    }
  fprintf(stdout, "\nAnzahl der Operatoren: %d\n", count);
}


/**********************************************************************
 *
 *********************************************************************/
void
print_plop(PlOperator * plop)
{
  if (NULL == plop) {
      fprintf(stdout,"\nEmpty Op\n");
  }

      fprintf(stdout,"\nOPERATOR ");
      print_hidden_tokenlist(plop->name, " ");
      fprintf(stdout,"\nparameters:\n");
      print_factlist ( plop->params, "\n", " : ");
      fprintf(stdout,"\n\npreconditions:\n");
      print_plnode(plop->preconds, 0);
      fprintf(stdout,"effects:\n");
      print_plnode(plop->effects, 0);
      fprintf(stdout,"\n-----\n");
}




void print_CodeOperator( CodeOperator *op )

{

  int i;
  Integers *in;

  if ( !op) {
    printf("\nEmpty Op\n");
    return;
  }

  printf("\nCoded Operator %s, parameters:", op->name);
  for ( i=0; i<op->num_vars; i++ ) {
    printf("\nx%d: %s", i, gtypes_table[op->var_types[i]].name);
    if ( gtypes_table[op->var_types[i]].name == gnew_types_name ) {
      printf("( ");
      for ( in = gtypes_table[op->var_types[i]].integers;
	    in; in = in->next ) {
	printf("%s ", gconstants_table[in->index]);
      }
      printf(")");
    }
  }
  printf("\n");

  printf("\nInstantiation:");
  for ( i=0; i<op->num_vars; i++ ) {
    printf("\nx%d: %s", i, 
	   op->inst_table[i] >=0 ? gconstants_table[op->inst_table[i]] : "?");
  }
  printf("\n");

  printf("\npreconds:\n");
  print_CodeNode( op->preconds, 0 );

  printf("conditionals:\n");
  print_CodeNode( op->conditionals, 0);

  printf("\n");

}







/*
 *
 */
void print_vector( BitVector *vec, int vec_len )

{

  int i, uid_block;
  unsigned int uid_mask;

  printf("\n");
  for (i=0; i < vec_len * gcword_size; i++) {
    if ( i % 8 == 0 && i != 0 ) {
      printf(":");
    }
    uid_block = i / gcword_size;
    uid_mask = 1 << ( i % gcword_size );
    if ( vec[uid_block] & uid_mask ) {
      printf("1");
    } else {
      printf("0");
    }
  }

}

/*
 *
 */
void 
print_fact_info(FactInfo * f_info, int vec_len)
{
  Integers * i;

  print_vector(f_info->vector, vec_len);
  
  if (NULL != f_info->indices)
    {
      fprintf(stdout, "%d", f_info->indices->index);

      for (i = f_info->indices->next; i; i = i->next)
	{
	  fprintf(stdout, ", %d", i->index);
	}
    }
  fprintf(stdout, "\n");
}



void print_plan( int time ) 

{

  OpNode *op;

  int i, j;
  Bool first;

  fprintf( OUT, "\nfound plan as follows:\n\n" );

  for ( i=0; i<time; i++ ) {
    fprintf( OUT, "time step %4d: ", i);
    first = TRUE;
    for ( j=0; j<gnum_ops_at[i]; j++ ) {
      op = gops_at[i][j];
      if ( op->is_noop ) continue;
      if ( first ) {
	print_op_name( op );
	fprintf( OUT, "\n" );
	first = FALSE;
      } else {
	fprintf( OUT, "                " );
	print_op_name( op );
	fprintf( OUT, "\n" );	
      }
    }
  }

}



void print_incremental_plan( Candidate *c )

{

  int time = gfirst_full_time + 1, i;
  Candidate *p;
  OpNode *op;
  Bool first;

  for ( p = c; p->father; p = p->father ) {   
    fprintf(OUT, "time step %4d: ", time++);
    first = TRUE;
    for ( i=0; p->ops[i] != NULL; i++ ) {
      op = p->ops[i];
      if ( op->is_noop ) continue;
      if ( first ) {
	print_op_name( op );
	fprintf( OUT, "\n" );
	first = FALSE;
      } else {
	fprintf( OUT, "                " );
	print_op_name( op );
	fprintf( OUT, "\n" );	
      }
    }
  }

  printf("\n");

}


void get_plan( int time ) 

{

  OpNode *op;

  int i, j;

  gnum_plan_ops = 0;
  for ( i=0; i<time; i++ ) 
    {
      for ( j=0; j<gnum_ops_at[i]; j++ ) 
	{
	  op = gops_at[i][j];
	  if ( op->is_noop ) continue;
	  gplan_ops[gnum_plan_ops] = op;
	  gnum_plan_ops++;
	}
    }  
}



void get_incremental_plan( Candidate *c )

{

  Candidate *p;
  OpNode *op;
  int i;

  for ( p = c; p->father; p = p->father ) 
    {   
      for ( i=0; p->ops[i] != NULL; i++ ) 
	{
	  op = p->ops[i];
	  if ( op->is_noop ) continue;
	  gplan_ops[gnum_plan_ops] = op;
	  gnum_plan_ops++;
	}
    }
  
}



void print_BitOperator( BitOperator *o )

{

  Effect *i;

  if ( !o ) {
    printf("\nempty BitOperator");
    return;
  }

  printf("\n");
  printf("\npos preconds:");
  print_FactInfo( o->p_preconds );
  printf("\nneg preconds:");
  print_FactInfo( o->n_preconds );

  printf("\nunconditional:");
  print_Effect( o->unconditional );

  printf("\nconditionals:");
  for ( i = o->conditionals; i; i = i->next ) {
    print_Effect( i );
  }

}



void print_Effect( Effect *e )

{

  if ( !e ) {
    printf("\nempty Effect");
    return;
  }

  printf("\npos conds");
  print_FactInfo( e->p_conds );
  printf("\nneg conds:");
  print_FactInfo( e->n_conds );
  printf("\npos effects");
  print_FactInfo( e->p_effects );
  printf("\nneg effects:");
  print_FactInfo( e->n_effects );


}



void print_FactInfo( FactInfo *f )

{

  Integers *i;
  RelevantFact *ff;

  if ( !f ) {
    printf("\nempty FactInfo");
    return;
  }

  printf("\nvector:");
  print_BitVector( f->vector, gft_vector_length );
  printf("\nthis is short for:");
  for ( i = f->indices; i; i = i->next ) {
    ff = grelevant_facts[i->index];
    printf("\n%d: ", i->index);
    print_fact( ff->predicate, ff->arguments );
  }

}



void print_BitVector( BitVector *vec, int vec_len )

{

  int i, uid_block;
  unsigned int uid_mask;

  printf("\n");
  for (i=0; i < vec_len * gcword_size; i++) {
    if ( i % 8 == 0 && i != 0 ) {
      printf(":");
    }
    uid_block = i / gcword_size;
    uid_mask = 1 << ( i % gcword_size );
    if ( vec[uid_block] & uid_mask ) {
      printf("1");
    } else {
      printf("0");
    }
  }

}




void print_fact( short int predicate, ArgArray arguments )

{

  int j;

  printf("%s(", gpredicates_table[predicate]);
  for ( j=0; j<garity[predicate]; j++ ) {
    printf("%s", gconstants_table[arguments[j]]);
    if ( j < garity[predicate] - 1 ) {
      printf(" ");
    }
  }
  printf(")");

}


void print_op_name( OpNode *op )

{

  int i;

  fprintf(OUT, "%s", op->name);
  for ( i=0; i<op->num_vars; i++ ) {
    fprintf(OUT, " %s", gconstants_table[op->inst_table[i]]);
  }

}


void print_ft_name( FtNode *ft )

{

  if ( !ft->positive ) {
    printf("NOT ");
  }
  print_fact( grelevant_facts[ft->index]->predicate,
	      grelevant_facts[ft->index]->arguments );

}