exclusions.c

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

    free( tmp );
#ifdef MEMORY_INFO
    gexcl_memory -= sizeof( FtPair );
#endif
  }
  gft_mutex_pairs = i;
  prev = i;
  if ( i ) i = i->next;
  while ( i ) {
    if ( !facts_are_exclusive( time, i->f1, i->f2 ) ) {
      MAKE_FTS_UNEXCLUSIVE( time, i->f1, i->f2 );
      gexclusions_count--;
      if ( i->f1->positive && i->f2->positive ) {
	gprint_exnum--;
      }
      prev->next = i->next;
      tmp = i;
      i = i->next;
      free( tmp );
#ifdef MEMORY_INFO
      gexcl_memory -= sizeof( FtPair );
#endif
    } else {
      prev = prev->next;
      i = i->next;
    }
  }

  for ( i1 = gall_fts_pointer; i1 != gprev_level_fts_pointer; i1 = i1->next ) {
    for ( i2 = i1->next; i2; i2 = i2->next ) {
      /* siehe oben
       */
      if ( i2->info_at[time]->is_dummy ) continue;
      if ( i1->index == i2->index ) {
	/* ==> contradicting facts!
	 *
	 * in dieser implemetierung WICHTIG: ft s muessen verschieden sein!
	 */
	continue;
      }
      if ( !facts_are_exclusive( time, i1, i2 ) ) {
	continue;
      }
      MAKE_FTS_EXCLUSIVE( time, i1, i2 );
      if ( i1->positive && i2->positive ) {
	gprint_exnum++;
      }
      gexclusions_count++;
      tmp = new_ft_pair( i1, i2 );
      tmp->next = gft_mutex_pairs;
      gft_mutex_pairs = tmp;
    }

    /* nun sind alle exclusions von i1 berechnet.
     *
     * falls i1 ein dummy war, der gerade erst richtig eingetragen wurde,
     * exclusions runterkopieren auf alle levels, wo i1 noch dummy war!
     */
    if ( i1->info_at[time-1] && 
	 i1->info_at[time-1]->is_dummy ) {
      SET_ADDERS( time, i1 );
      for ( j=time-1; j>0; j-- ) {
	if ( !i1->info_at[j] ) break;

	if ( !i1->info_at[j]->is_dummy ) {/* NUR ZUR VORSICHT... */
	  printf("des kann aber net soi!");
	  exit( 1 );
	}
	
	free( i1->info_at[j]->pos_exclusives );
	free( i1->info_at[j]->neg_exclusives );
	i1->info_at[j]->pos_exclusives = i1->info_at[time]->pos_exclusives;  
	i1->info_at[j]->neg_exclusives = i1->info_at[time]->neg_exclusives;
      }
    }

  }/* for i1 ... */

}








/**********************************************
 * HELPERS ON RELATIONS BETWEEN OPS AND FACTS *
 **********************************************/








Bool competing_needs( int time, OpNode *o1, OpNode *o2 )

{

  BitVector *p = o1->unconditional->info_at[time]->cond_pos_exclusives;
  BitVector *n = o1->unconditional->info_at[time]->cond_neg_exclusives;
  BitVector *b;
  int r;
  FtEdge *i;
  

  if ( !p ) {
    p = new_excl_bit_vector( gft_vector_length );
    n = new_excl_bit_vector( gft_vector_length );
    for ( i = o1->preconds; i; i = i->next ) {
      b = i->ft->info_at[time]->pos_exclusives;
      for ( r = 0; r < gft_vector_length; r++ ) {
	p[r] |= b[r];
      }
      b = i->ft->info_at[time]->neg_exclusives;
      for ( r = 0; r < gft_vector_length; r++ ) {
	n[r] |= b[r];
      }
    }
    o1->unconditional->info_at[time]->cond_pos_exclusives = p;
    o1->unconditional->info_at[time]->cond_neg_exclusives = n;
  }

  b = o2->pos_precond_vector;
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( p[r] & b[r] ) {
      return TRUE;
    }
  }
  b = o2->neg_precond_vector;
  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( n[r] & b[r] ) {
      return TRUE;
    }
  }
  return FALSE;

}


Bool interfere( OpNode *i1, OpNode *i2 )

{

  BitVector *e1p = i1->unconditional->pos_effect_vector;
  BitVector *e1n = i1->unconditional->neg_effect_vector;
  BitVector *e2p = i2->unconditional->pos_effect_vector;
  BitVector *e2n = i2->unconditional->neg_effect_vector;
  BitVector *p1p = i1->pos_precond_vector;
  BitVector *p1n = i1->neg_precond_vector;
  BitVector *p2p = i2->pos_precond_vector;
  BitVector *p2n = i2->neg_precond_vector;

  int r;

  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( (e1p[r] | p1p[r]) & (e2n[r] | p2n[r]) ) {
      return TRUE;
    }
  }

  for ( r = 0; r < gft_vector_length; r++ ) {
    if ( (e2p[r] | p2p[r]) & (e1n[r] | p1n[r]) ) {
      return TRUE;
    }
  }

  return FALSE;

}


Bool noop_exclusive( OpNode *i1, OpNode *i2 )

{

  OpNode *noop, *op;
  FtNode *ft;
  BitVector *vec;

  if ( !i1->is_noop && !i2->is_noop ) return FALSE;
  if ( i1->is_noop && i2->is_noop ) return FALSE;

  noop = i1->is_noop ? i1 : i2;
  op = i1->is_noop ? i2 : i1;
  ft = noop->preconds->ft;

  /*
   * achtung! wenn s keinen unconditional effect gibt, werden
   * diese vectoren in build_graph.c mit 0 gesetzt!
   */
  if ( ft->positive ) {
    vec = op->unconditional->pos_effect_vector;
  } else {
    vec = op->unconditional->neg_effect_vector;
  }

  if ( vec[ft->uid_block] & ft->uid_mask ) {
    return TRUE;
  } else {
    return FALSE;
  }

}
  
  
Bool facts_are_exclusive( int time, FtNode *f1, FtNode *f2 )

{

  BitVector *excl = f2->info_at[time]->adders_exclusives;
  BitVector *b;
  int r;
  EfEdge *i, *j;
  Bool first = TRUE;
  
  OpNode *op1, *op2;
  FtEdge *ip, *jp;


  if ( f1->noop ) {
    op1 = f1->noop;
    for ( j = f2->adders; j; j = j->next ) {
      op2 = j->ef->op;
      if ( !ARE_MUTEX_OPS( time-1, op1, op2 ) ) {
	for ( jp=j->ef->conditions; jp; jp = jp->next ) {
	  if ( ARE_MUTEX_FTS( time-1, f1, jp->ft ) ) break;
	}
	if ( jp ) {
	  if ( 0 ) {
	    printf("\nnoop - op pair bad!");
	  }
	  continue;
	}
	return FALSE;
      }
    }
  }
  if ( f2->noop ) {
    op1 = f2->noop;
    for ( j = f1->adders; j; j = j->next ) {
      op2 = j->ef->op;
      if ( !ARE_MUTEX_OPS( time-1, op1, op2 ) ) {
	for ( jp=j->ef->conditions; jp; jp = jp->next ) {
	  if ( ARE_MUTEX_FTS( time-1, f2, jp->ft ) ) break;
	}
	if ( jp ) {
	  if ( 0 ) {
	    printf("\nnoop - op pair bad!");
	  }
	  continue;
	}
	return FALSE;
      }
    }
  }

  for ( i = f1->adders; i; i = i->next ) {
    for ( j = f2->adders; j; j = j->next ) {
      op1 = i->ef->op;
      op2 = j->ef->op;
      if ( !ARE_MUTEX_OPS( time-1, op1, op2 ) ) {

	for ( ip = i->ef->conditions; ip; ip = ip->next ) {
          for ( jp = j->ef->conditions; jp; jp = jp->next ) {
            if ( ARE_MUTEX_FTS( time-1, ip->ft, jp->ft ) ) break;
	  }
          if ( jp ) break;

          for ( jp = op2->preconds; jp; jp = jp->next ) {
            if ( ARE_MUTEX_FTS( time-1, ip->ft, jp->ft ) ) break;
	  }
          if ( jp ) break;
        }
        if ( ip ) {
	  if ( 0 ) {
	    printf("\nop pair bad!");
	  }
	  continue;
	}

        for ( ip = op1->preconds; ip; ip = ip->next ) {
          for ( jp = j->ef->conditions; jp; jp = jp->next ) {
            if ( ARE_MUTEX_FTS( time-1, ip->ft, jp->ft ) ) break;
	  }
          if ( jp ) break;
        }
        if ( ip ) {
	  if ( 0 ) {
	    printf("\nop pair bad!");
	  }
	  continue;
	}

	return FALSE;

      }
    }
  }

  return TRUE;


  /* bit vector code a la STAN;
   * funktioniert nur bei unconditional domains,
   * sonst kann man effect conds - excl nicht
   * abfragen.
   *
   * laengerfristig: EXCL UEBER EFFECTS DEFINIEREN!!!
   */
  if ( !excl ) {
    if ( f2->noop ) {
      excl = copy_bit_vector( f2->noop->info_at[time-1]->exclusives, gop_vector_length_at[time-1] );
      first = FALSE;
    }
    for ( i = f2->adders; i; i = i->next ) {
      if ( !f2->noop && first ) {
	excl = copy_bit_vector( i->ef->op->info_at[time-1]->exclusives, gop_vector_length_at[time-1] );
	first = FALSE;
      }
      b = i->ef->op->info_at[time-1]->exclusives;
      for ( r = 0; r < gop_vector_length_at[time-1]; r++ ) {
	excl[r] &= b[r];
      }
    }
    f2->info_at[time]->adders_exclusives = excl;
  }

  b = f1->info_at[time]->adders;
  for ( r = 0; r < gop_vector_length_at[time-1]; r++ ) {
    if ( b[r] != ( b[r] & excl[r] ) ) {
      break;
    }
  }

  return ( r == gop_vector_length_at[time-1] );

}