build_graph.c

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

  
Bool are_there_non_exclusive( int time, FactInfo *pos, FactInfo *neg )

{

  BitVector *a, *b;
  Integers *i;
  int r;

  /* !!!!!!!!!!!!!!!!!!!!!!!!
   * hier lieber einzeln die fakten auslesen!!
   * genauso eins weiter unten in get_them...
   */
  a = pos->vector;
  b = gpos_facts_vector_at[time];
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( a[r] != (a[r] & b[r]) ) {
      return FALSE;
    }
  }
  a = neg->vector;
  b = gneg_facts_vector_at[time];
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( a[r] != (a[r] & b[r]) ) {
      return FALSE;
    }
  }

  /* geht das EFFIZIENTER durch zusammen OR-en der exclusives ??
   */
  for ( i=pos->indices; i; i=i->next ) {
    a = gft_table[i->index]->info_at[time]->pos_exclusives;
    b = gft_table[i->index]->info_at[time]->neg_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      if ( (pos->vector[r] & a[r]) || (neg->vector[r] & b[r]) ) {
	return FALSE;
      }
    }
  }
  for ( i=neg->indices; i; i=i->next ) {
    a = gft_table[NEG_ADR( i->index )]->info_at[time]->pos_exclusives;
    b = gft_table[NEG_ADR( i->index )]->info_at[time]->neg_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      if ( (pos->vector[r] & a[r]) || (neg->vector[r] & b[r]) ) {
	return FALSE;
      }
    }
  }
    
  return TRUE;

}


Bool get_them_non_exclusive( int time,
			     FactInfo *pos, FactInfo *neg,
			     BitVector **pos_exclusives, BitVector **neg_exclusives )

{

  BitVector *a, *b;
  int r;
  Integers *i;

  a = pos->vector;
  b = gpos_facts_vector_at[time];
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( a[r] != (a[r] & b[r]) ) {
      return FALSE;
    }
  }
  a = neg->vector;
  b = gneg_facts_vector_at[time];
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( a[r] != (a[r] & b[r]) ) {
      return FALSE;
    }
  }

  *pos_exclusives = new_excl_bit_vector( gft_vector_length );
  *neg_exclusives = new_excl_bit_vector( gft_vector_length );

  for ( i=pos->indices; i; i=i->next ) {
    b = gft_table[i->index]->info_at[time]->pos_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      (*pos_exclusives)[r] |= b[r];
      if ( pos->vector[r] & (*pos_exclusives)[r] ) {
	free( *pos_exclusives );
	free( *neg_exclusives );
	return FALSE;
      }
    }
    b = gft_table[i->index]->info_at[time]->neg_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      (*neg_exclusives)[r] |= b[r];
      if ( neg->vector[r] & (*neg_exclusives)[r] ) {
	free( *pos_exclusives );
	free( *neg_exclusives );
	return FALSE;
      }
    }
  }
  for ( i=neg->indices; i; i=i->next ) {
    b = gft_table[NEG_ADR( i->index )]->info_at[time]->pos_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      (*pos_exclusives)[r] |= b[r];
      if ( pos->vector[r] & (*pos_exclusives)[r] ) {
	free( *pos_exclusives );
	free( *neg_exclusives );
	return FALSE;
      }
    }
    b = gft_table[NEG_ADR( i->index )]->info_at[time]->neg_exclusives;
    for ( r = 0; r < gft_vector_length; r++ ) {
      (*neg_exclusives)[r] |= b[r];
      if ( neg->vector[r] & (*neg_exclusives)[r] ) {
	free( *pos_exclusives );
	free( *neg_exclusives );
	return FALSE;
      }
    }
  }

  return TRUE;

}









/******************
 * SIMPLE HELPERS *
 ******************/









void insert_op_edge( OpEdge **l, OpNode *op )

{

  OpEdge *new_edge = new_op_edge( op );

  new_edge->next = *l;
  *l = new_edge;

}

void insert_ef_edge( EfEdge **l, EfNode *ef )

{

  EfEdge *new_edge = new_ef_edge( ef );

  new_edge->next = *l;
  *l = new_edge;

}

void insert_ft_edge( FtEdge **l, FtNode *ft )

{

  FtEdge *new_edge = new_ft_edge( ft );

  new_edge->next = *l;
  *l = new_edge;

}









/************************************************************************
 * FOR RIFO META STRATEGY: GRAPH AND MEMOs, WAVE FRONT FREEING FUNCTION * 
 ************************************************************************/









void free_graph_and_search_info( void )

{

  int i;

  for ( i = 0; i < 2 * gnum_relevant_facts; i++ ) {
    /* memo s are freed as a side effect of freeing facts, as
     * memo trees start in fact level infos
     */
    /* free_ft_node( gft_table[i] ); */
    gft_table[i] = NULL;
  }
  /* free( gft_table ); */
  gall_fts_pointer = NULL;
  gprev_level_fts_pointer = NULL;

  /* effects get wiped away with ops: they are connected only to
   * their corresponding op nodes
   */
  free_op_node( gall_ops_pointer );
  gall_ops_pointer = NULL;
  gprev_level_ops_pointer = NULL;
  gops_with_unactivated_effects_pointer = NULL;

  /* free_op_pair( gop_mutex_pairs );
     free_ft_pair( gft_mutex_pairs ); */
  gop_mutex_pairs = NULL;
  gft_mutex_pairs = NULL;
  
  gfacts_count = 0;
  gexclusions_count = 0;
  gops_count = 0;
  gops_exclusions_count = 0;
  gprint_ftnum = 0;
  gprint_exnum = 0;

  for ( i = 0; i < MAX_PLAN; i++ ) {
    free( gpos_facts_vector_at[i] );
    free( gneg_facts_vector_at[i] );
  }

  gsame_as_prev_flag = FALSE;
  gfirst_full_time = 0;

  /* free_candidate( gwave_front_head );
     free_candidate( gwave_front_trash ); */
  gwave_front_head = NULL;
  gwave_front_tail = NULL;
  gwave_front_trash = NULL;
  gplan_start = NULL;

}



void free_op_node( OpNode *op )

{

  int i;

  if ( op ) {
    free_op_node( op->next );

    free( op->name );
    free_ft_edge( op->preconds );
    free_ef_node( op->unconditional );
    free_ef_node( op->conditionals );
    for ( i = 0; i < MAX_PLAN; i++ ) {
      free_op_level_info( op->info_at[i] );
    }
    free_effect( op->unactivated_effects );

    free( op );
  }

}



void free_ef_node( EfNode *ef )

{

  int i;

  if ( ef ) {
    free_ef_node( ef->next );

    free_ft_edge( ef->conditions );
    free_ft_edge( ef->effects );
    free( ef->pos_effect_vector );
    free( ef->neg_effect_vector );
    for ( i = 0; i < MAX_PLAN; i++ ) {
      free_ef_level_info( ef->info_at[i] );
    }

    free( ef );
  }

}



void free_ft_node( FtNode *ft )

{

  int i;

  if ( ft ) {
    free_ef_edge( ft->adders );
    free_op_edge( ft->preconds );
    for ( i = 0; i < MAX_PLAN+1; i++ ) {
      free_ft_level_info( ft->info_at[i] );
    }

    free( ft );
  }

}



void free_memo_node( MemoNode *m )

{

  int i;

  if ( m ) {
    free_memo_node( m->next );
    for ( i = 0; i < MEMO_HASHSIZE; i++ ) {
      free_memo_node( (*(m->sons))[i] );
    }
    free( m->sons );

    free( m );
  }

}



void free_op_level_info( OpLevelInfo *i )

{

  if ( i ) {
    free( i->exclusives );

    free( i );
  }

}



void free_ef_level_info( EfLevelInfo *i )

{

  if ( i ) {
    if ( i->cond_pos_exclusives )
      free( i->cond_pos_exclusives );
    if ( i->cond_neg_exclusives ) 
      free( i->cond_neg_exclusives );

    free( i );
  }

}



void free_ft_level_info( FtLevelInfo *i )

{

  if ( i ) {
    free( i->pos_exclusives );
    free( i->neg_exclusives );
    free( i->adders );
    free( i->adders_exclusives );
    
    free_memo_node( i->memo_start );

    free( i );
  }

}



void free_op_edge( OpEdge *e )

{

  if ( e ) {
    free_op_edge( e->next );

    free( e );
  }

}



void free_ef_edge( EfEdge *e )

{

  if ( e ) {
    free_ef_edge( e->next );

    free( e );
  }

}



void free_ft_edge( FtEdge *e )

{

  if ( e ) {
    free_ft_edge( e->next );

    free( e );
  }

}



void free_op_pair( OpPair *p )

{

  if ( p ) {
    free( p->next );

    free( p );
  }

}



void free_ft_pair( FtPair *p )

{

  if ( p ) {
    free( p->next );

    free( p );
  }

}



void free_candidate( Candidate *c )

{

  if ( c ) {
    free( c->next );

    free( c );
  }

}