create_supp.c

主要用于大规模的测试生成方法

	err = 0;

	for( i = 0; i < n_descr; i++ )
	{
		for( j = 0; j < descr[i].fanin; j++ )
		{
		    found = 0;
		    for( k = 0; k < descr[descr[i].from[j]].fanout; k++ )
			if( descr[descr[i].from[j]].to[k] == i )
			    found = 1;

		    if( !found && descr[i].attr != PI )
		    {
			 err++;
			 printf( "(check_netlist) ERROR checking to field: %d, %s\n", i, descr[i].name );
		    }
		}
	}

	if(!create_silent) printf( "Fanin check: " );
	if( err == 0 )
		if(!create_silent) printf( "passed\n" );
	else
		if(!create_silent) printf( "failed, %d errors found\n", err );
}


void	check_level( void )
{
	int	i, j, err;


	/* Faccio alcuni controlli sul livello */
	if(!create_silent) printf( "\nChecking level\n" ); 
	if(!create_silent) printf( "---------------\n" );

	err = 0;
	for( i = 0; i < n_descr; i++ )
		for( j = 0; j < descr[i].fanin; j++ )
			if( (descr[i].level <= descr[descr[i].from[j]].level && descr[i].type != FF) && descr[i].attr != PI )
			{
				printf( "(check_level) Gate %d (%s) has level %d, lower than gate %d (%s) level %d",
				i, descr[i].name, descr[i].level,
				descr[i].from[j], descr[descr[i].from[j]].name,
				descr[descr[i].from[j]].level);

				/*MVMV */
				printf( "Repaired\n" );
				descr[i].level++;
				
				err++;
			}

	if(!create_silent) printf( "%d errors found\n\n", err );
}

void	destroy_reset( int reset_d, int preset_d )
{

	DESCRIPTOR	*new_descr;
	int		i, j, new_n_descr;
	char		*temp;


	#if TRACE == 1
		printf( "[destroy_reset]\n" );
	#endif

	if( (reset_d == -1) && (preset_d == -1) )
		return;

	if(!create_silent) {   /* [gs, 27-11-96] added line */
	    printf( "Removing reset and preset\n" );
	    printf( "-------------------------\n" );
	    if( reset_d != -1 )
		printf( "reset = %s\n", descr[reset_d].name );
	    else
		printf( "reset not present\n" );
	    if( preset_d != -1 )
		printf( "preset = %s\n", descr[preset_d].name );
	    else
		printf( "preset not present\n" );
	    printf( "\n" );
	}                      /* [gs, 27-11-96] added line */
	
	new_n_descr = n_descr;	/* non ho ancora cancellato nulla */

	/* alloco la memoria per il nuovo descrittore */
	if( ((reset_d != -1) && (preset_d != -1)) 
	    && (reset_d != preset_d) )
	{
		if(!create_silent) printf( "(destroy_reset) Lowering descr by 2\n" );
		new_descr = (DESCRIPTOR *)malloc( sizeof(DESCRIPTOR)*(n_descr-2) );
	}
	else
	{
		if(!create_silent) printf( "(destroy_reset) Lowering descr by 1\n" );
		new_descr = (DESCRIPTOR *)malloc( sizeof(DESCRIPTOR)*(n_descr-1) );
	}

	if( new_descr == NULL )
	{
		printf( "(destroy_reset) Memory error, quitting...\n" );
		exit( 1 );
	}

	j = 0;
	for( i = 0; i < n_descr; i++ )
		if( (i != reset_d) && (i != preset_d) )	/* salta il descrittore del reset */
		{
			new_descr[j].attr = descr[i].attr;
			new_descr[j].type = descr[i].type;
/*			new_descr[j].espl = descr[i].espl;*/
			new_descr[j].fanin = descr[i].fanin;
			new_descr[j].fanout = descr[i].fanout;
			new_descr[j].level = descr[i].level;
			new_descr[j].to = descr[i].to;
			new_descr[j].from = descr[i].from;
			new_descr[j].name = descr[i].name;
			new_descr[j].to_name = descr[i].to_name;
			new_descr[j].ff_type = descr[i].ff_type;
			new_descr[j].gate_id = descr[i].gate_id;
			j++;
		}
		else
			if(!create_silent) printf( "(destroy_reset) Skipping %d, %s\n", i, descr[i].name );

		
	/* setto il corretto numero di descrittori e PI */

	if( ((reset_d != -1) && (preset_d != -1))
            && (reset_d != preset_d) )
	{
		if(!create_silent) printf( "(destroy_reset) Removed 2 PI\n" );
		new_n_descr -= 2;
	}
	else
	{
		if( reset_d == preset_d )
			preset_d = -1;	/* cancello solo uno dei due */

		if( reset_d != -1 )
			if(!create_silent) printf( "(destroy_reset) Removed 1 PI\n" );

		if( preset_d != -1 )
			if(!create_silent) printf( "(destroy_reset) Removed 1 PI" );
		new_n_descr -= 1;
	}

	if(!create_silent) printf( "(destroy_reset) Resizing FF fanin\n" );

	for( i = 0; i < n_descr; i++ )
		if( descr[i].type == FF )
			descr[i].fanin = 2;

	for( i = 0; i < new_n_descr; i++ )
		if( new_descr[i].type == FF )
			new_descr[i].fanin = 2;	/* fissa a 2 il fanin dei FF */

	
	/* se c'e RESET riduci di uno */
	if( reset_d != -1 )
	{
		n_sub_descr++;
		reset_pos = reset_d;
		if( preset_d != -1 )
			preset_pos = preset_d;

		if(!create_silent) printf( "(destroy_reset) Adjusting for reset...\n" );

		for( i = 0; i < new_n_descr; i++ )
		{
			for( j = 0; j < new_descr[i].fanin; j++ )
				if( new_descr[i].from[j] >= reset_d ) 
					if( new_descr[i].from[j] >= preset_d 
					    && preset_d != -1 )
						new_descr[i].from[j] -= 2;
					else
						new_descr[i].from[j]--;

			for( j = 0; j < new_descr[i].fanout; j++ )
				if( new_descr[i].to[j] >= reset_d ) 
					if( new_descr[i].to[j] >= preset_d 
					    && preset_d != -1 )
						new_descr[i].to[j] -= 2;
					else
						new_descr[i].to[j]--;
		}
	}

	/* se c'e PRESET riduci di uno */
	if( preset_d != -1 && reset_d == -1 )
	{
		n_sub_descr++;
		preset_pos = preset_d;
		if(!create_silent) printf( "(destroy_reset) Adjusting for preset...\n" );

		for( i = 0; i < new_n_descr; i++ )
		{
			for( j = 0; j < new_descr[i].fanin; j++ )
				if( new_descr[i].from[j] >= preset_d ) 
					new_descr[i].from[j]--;
			for( j = 0; j < new_descr[i].fanout; j++ )
				if( new_descr[i].from[j] >= preset_d ) 
					new_descr[i].to[j]--;
		}
	}
	
	/* libero la memoria occupata dal vecchio descr */

	
	free( descr );

	descr = new_descr;
	n_descr = new_n_descr;
	
}

/*
int	find_clock_descr( void )
{
	int	i, j;
	int	found;	

	found = -1;

	for( i = 0; i < n_net; i++ )
		for( j = 0; j < netlist[i].n_info; j++ )
			if( !strcmp( pinlist[j+netlist[i].list].pin_name, pin_name_ffd[1] )  )
			{
				found = i;
				break;
			}

	if( found == -1 )
		return( -1 );

	for( i = 0; i < n_descr; i++ )
		if( descr[i].attr == PI )
			if( !strcmp( netlist[found].netname, descr[i].name ) )
				return( i );

	return( -1 );
}
*/

int	find_clock_descr( void )
{
	int	i;
	int	found;	

	found = -1;

	if(!create_silent) printf( "(find_clock_descr) Looking for clock PI...\n" );

	for( i = 0; i < n_pin; i++ )
	{
		if( descr[pinlist[i].n_descr].type == FF )
			if( !strcmp( pinlist[i].pin_name, pin_name_ffd[1] ) )
			{
				/*
				printf( "%s, %s\n", pinlist[i].pin_name, pin_name_ffd[1] );
				*/

				found = i;
				break;
			}		
	}

	if( found == -1 )
		return( -1 );

	if( descr[pinlist[found].n_descr].type != FF )
	{
		printf( "(find_clock_descr) ERROR: clock gating\n" );
		return( -1 );
	}
	
	
	for( i = 0; i < n_descr; i++ )
		if( descr[i].attr == PI )
			if( !strcmp( netlist[pinlist[found].net_index].netname, descr[i].name ) )
			{
				if(!create_silent) printf( "(find_clock_descr) found descriptor %d, %s\n", i, descr[i].name );

				return( i );
			}

	printf( "(find_clock_descr) ERROR: clock is not a PI, quitting...\n" );
	exit( 1 );
}

int	find_reset_descr( void )
{
	int	i;
	int	found;	

	found = -1;

	/* cerco un pin che si chiami come pin_name_ffr[2] */

	ResetDescrName = NULL;

	for( i = 0; i < n_pin; i++ )
		if( !strcmp( pinlist[i].pin_name, pin_name_ffr[2] ) &&
		    descr[pinlist[i].n_descr].type == FF )
		{
			found = i;
			break;
		}		

	if( found == -1 )
		return( -1 );

	if( descr[pinlist[found].n_descr].type != FF )
		return( -1 );
	
	/* controllo che il reset sia un PI */
	
	for( i = 0; i < n_descr; i++ )
		if( descr[i].attr == PI )
			if( !strcmp( netlist[pinlist[found].net_index].netname, descr[i].name ) )
			{
				ResetDescrName = strdup( descr[i].name );
				return( i );
			}

	return( -1 );
}

int	find_preset_descr( void )
{
	int	i;
	int	found;	

	found = -1;

	/* cerco un pin che si chiami come pin_name_ffp[2] */

	PresetDescrName = NULL;

	for( i = 0; i < n_pin; i++ )
		if( !strcmp( pinlist[i].pin_name, pin_name_ffp[2] ) &&
		    descr[pinlist[i].n_descr].type == FF )
		{
			found = i;
			break;
		}		

	if( found == -1 )
		return( -1 );

	if( descr[pinlist[found].n_descr].type != FF )
		return( -1 );
	
	/* controllo che il reset sia un PI */
	
	for( i = 0; i < n_descr; i++ )
		if( descr[i].attr == PI )
			if( !strcmp( netlist[pinlist[found].net_index].netname, descr[i].name ) )
			{
				PresetDescrName = strdup( descr[i].name );
				return( i );
			}

	return( -1 );
}

/*
int	find_preset_descr( void )
{
	int	i, j;
	int	found;	

	found = -1;

	for( i = 0; i < n_net; i++ )
		for( j = 0; j < netlist[i].n_info; j++ )
			if( !strcmp( pinlist[j+netlist[i].list].pin_name, pin_name_ffp[2] )  )
			{
				found = i;
				break;
			}

	if( found == -1 )
		return( -1 );

	for( i = 0; i < n_descr; i++ )
		if( descr[i].attr == PI )
			if( !strcmp( netlist[found].netname, descr[i].name ) )
				return( i );

	return( -1 );
}
*/

void	check_ff_fanin( void )
{
	int	i, err;

	if(!create_silent) printf( "\nChecking ff fanin\n" );
	if(!create_silent) printf( "-----------------\n" );
	err = 0;
	for( i = 0; i < n_descr; i++ )
	{
		if( descr[i].type == FF )
		{
			if( (descr[i].fanin < 2) || (descr[i].fanin > 4) )
			{
				err++;
				printf( "ERROR on %d, %s, fanin = %d\n", i, descr[i].name, descr[i].fanin );
			}
		}
	}
	if(!create_silent) printf( "%d error found\n\n", err );

	if( err != 0 )
	{
		printf( "Exiting...\n" );
		exit( 1 );
	}
}
				
void	find_clock_tree( void )
{
	int	i;

	for( i = 0; i < n_descr; i++ )
		if( (descr[i].attr == INTERNAL) &&
		    (descr[i].type == FF) )
			{
				ClockDescr = descr[i].from[1];

				return;
			}
}

void	create_netlist( int mode )
{
	int	i, j, out_el, k;
	int	fanout;
	int	*dummy_p;
	int	dummy_l;	

	int	clock_descr;
	int	reset_descr;
	int	preset_descr;

	int	max_len;
	int	n_elem;

	int	p1, p2, p3, p4;
	int	pin_pos;


	extern	get_pin_pos();

	/*
	init_library();
	*/

	#if TRACE == 1
		printf( "[create_netlist]\n" );
	#endif
	if( !mode )
		printf( "Building netlist...\n" );


	/*
	if( VERBOSE )
		dump_netlist();
	*/	/* creo il file netlist.log */

	
	/*
	if( VERBOSE )
		dump_descr();
	*/
	


	for( i = 0; i < n_net; i++ )
	{	/* cerca il nodo di uscita */
		out_el = -1;	/* descrittore dell'elemeto di uscita */
		fanout = netlist[i].n_info-1;
	
		for( j = 0; j < netlist[i].n_info; j++ )
			if( pinlist[j+netlist[i].list].dir == OUT )	
				out_el = pinlist[j+netlist[i].list].n_descr;

		if( out_el == -1 )
		{
			printf( "ERROR 7: Output descriptor not found, net %d\n", i );
			exit( 1 );
		}

		/* alloca la memoria per il descrittore corrente */
		if( fanout != 0 )
			descr[out_el].to_name = strdup( netlist[i].netname );

		descr[out_el].fanout = fanout;	

		descr[out_el].to = malloc( sizeof( int )*fanout );
		if( descr[out_el].to == NULL )
		{
			printf( "(create_netlist) Memory error, quitting...\n" );
			exit( 1 );
		}
	
		/* scrive il campo to della porta di output */
		k = 0;
		for( j = 0; j < netlist[i].n_info; j++ )
			if( pinlist[j+netlist[i].list].dir == IN )
				descr[out_el].to[k++] = pinlist[j+netlist[i].list].n_descr;

		/* Aggiunge la porta di uscita nel campo from di ogni porta
		   connessa.
		   Questa parte puo` dare dei problemi nel caso che il fanin
		   sia maggiore di MAX_FANIN */
		for( j = 0; j < netlist[i].n_info; j++ )
			if( pinlist[j+netlist[i].list].dir == IN )
			{
				/* identifica il descrittore a cui modificare 
				   il fanin */
				k = pinlist[j+netlist[i].list].n_descr;

				/* identifica la posizione in cui scrivere
				   il nuovo elemento in from, sulla base del
				   nome del pin a cui ci si connette:
				   l'ordine in from corrisponde all'ordine
				   dei pin nella libreria */
				pin_pos = get_pin_pos( pinlist[j+netlist[i].list].pin_name );
				
				if( descr[k].attr != PO && pin_pos == -1 )
				{
					printf( "(create_netlist) pin name not known\n" );
					printf("descr %d, name=%s\n", k, pinlist[j+netlist[i].list].pin_name ) ;
					exit( 1 );
				}

				if( descr[k].fanin >= MAX_FANIN )
				{
					printf( "(create_netlist) Fanin over MAX_FANIN\n" );
					exit( 1 );
				}

				if( descr[k].attr == PO )
					descr[k].from[descr[k].fanin++] = out_el;
				else
				{
					descr[k].from[pin_pos] = out_el;
					descr[k].fanin++;
				}

				if( descr[k].fanin >= MAX_FANIN )
				{
					printf( "(create_netlist) Fanin too high\n" );
					return;
				}
			}
	}
	

	/* fisso la dimensione corretta del descrittore */
	descr = realloc( descr, n_descr*sizeof( DESCRIPTOR ) );

	/* fisso la dimensione corretta del campo descr[i].from */
	for( i = 0; i < n_descr; i++ )
		if( descr[i].fanin < MAX_FANIN )
		{
			dummy_l = descr[i].fanin;
			dummy_p = realloc( descr[i].from, dummy_l*sizeof( int ) );
			descr[i].from = dummy_p;
		}