CLofig::CLofig (string &name)
{
loins_list *pLoins;
cmess1 << " o Loading netlist \"" << name << "\"...\n";
fig = getlofig ((char *)name.c_str (), 'A');
// Build the instances dictionnary (map).
for (pLoins = fig->LOINS; pLoins != NULL; pLoins = pLoins->NEXT) {
instances[pLoins->INSNAME] = pLoins;
}
}
void lecture_vues(char *nom_circuit_lo, COEUR *lecoeur, lofig_list **circuit_lo,
chain_list **liste_plotsph, int *nbplots, chain_list **lst_conestouest)
{
chain_list * lstph;
phfig_list * ptfig;
loins_list * circuit_inst; /* instances dans le circuit logique */
loins_list * coeur_inst = NULL; /* instance du coeur */
int nbcoeur = 0; /* nombres d'instances susceptibles d'etre le coeur */
int retour;
*circuit_lo = getlofig(nom_circuit_lo, 'A');
if (!(*circuit_lo))
ringerreur(ERR_CIRCUITLO, nom_circuit_lo, NULL);
/* viewlo(); */
circuit_inst = (*circuit_lo)->LOINS;
if (!circuit_inst)
ringerreur(ERR_CIRCUITINST, nom_circuit_lo, NULL);
/* ---------------------------------------------------------------------------------------------------------- */
/* test la coherences des modeles logiques et physiques de toutes les modeles utilisee dans la figure logique */
/* ---------------------------------------------------------------------------------------------------------- */
testcon_modelfig(*circuit_lo);
/* ------------------------------------------------------------------------------------------------------------- */
/* Parcours des instances pour distinguer celles qui sont des plots et les autres (normalement 1 seule: le coeur */
/* ------------------------------------------------------------------------------------------------------------- */
*nbplots = 0;
(*liste_plotsph) = NULL; /* Initialisation de la liste de plots physiques */
while (circuit_inst != NULL) {
retour = incatalog(circuit_inst->FIGNAME);
if (mode_debug)
printf("FIGNAME %s incatalog %d\n", circuit_inst->FIGNAME, retour);
if (retour) {
(*nbplots)++;
/* -------------------------------------- */
/* Renommage des connecteurs vdd* et vss* */
/* -------------------------------------- */
ajout_listeplotsph(circuit_inst->FIGNAME, liste_plotsph);
} else /* le coeur est reconnu */ {
nbcoeur++;
coeur_inst = circuit_inst;
}
circuit_inst = circuit_inst->NEXT;
}
if (mode_debug)
printf("Lirevues: nb inst plots %d\n", *nbplots);
/* -------------------------------------------- */
/* Verification sur le nombres de coeur trouves */
/* -------------------------------------------- */
switch (nbcoeur) {
case 0:
ringerreur(ERR_NONCOEUR, NULL, NULL); /* aucun => ringerreur */
break;
case 1:
/* ------------------------------------------------------ */
/* un seul coeur, on charge les vues logique et physique */
/* ------------------------------------------------------ */
(*lecoeur).coeur_lo = coeur_inst;
if ((*lecoeur).coeur_lo == NULL)
ringerreur(ERR_COEURINSTLO, coeur_inst->FIGNAME, NULL);
ptfig = (*lecoeur).coeur_ph = getphfig(coeur_inst->FIGNAME, 'A');
(*lecoeur).coord.xabs = 0;
(*lecoeur).coord.yabs = 0; /* Coordonnees du coeur fixees a 0,0 par defaut */
(*lecoeur).width = ptfig->XAB2 - ptfig->XAB1;
(*lecoeur).height = ptfig->YAB2 - ptfig->YAB1;
(*lecoeur).coord.piste = 0;
(*lecoeur).rotation = NOSYM; /* pas de rotation par defaut */
/* viewphfig((*lecoeur).coeur_ph); */
if ((*lecoeur).coeur_ph == NULL)
ringerreur(ERR_COEURINSTPH, coeur_inst->FIGNAME, NULL);
break;
default:
/* ------------------------------------------ */
/* plusieurs candidats au coeur => ringerreur */
/* ------------------------------------------ */
ringerreur(ERR_PLUSCOEUR, (*circuit_lo)->LOINS, NULL);
}
/* ----------------------------------------------------- */
/* verification des modeles pour connexion alim internes */
/* ----------------------------------------------------- */
lstph = *liste_plotsph;
while (NULL != lstph) {
verif_con_estouest(lstph, lst_conestouest);
lstph = lstph->NEXT;
}
if (mode_debug)
affic_listeplotsph(*liste_plotsph);
}
static int insert_buffer(losig_list* losig, lofig_list* lofig, int optim_level, long index)
{
double capa, init_capa;
cell_list* buffer;
chain_list* namechain, *sigchain=NULL;
char* signame;
lofig_list* model;
losig_list* losig_buf;
loins_list* loins_buf;
locon_list* locon;
losig_list* losig_vdd=NULL, *losig_vss=NULL, *losig_aux;
ptype_list* ptype, *buffer_ptype;
double delay, best_delay, init_delay;
loins_list* loins;
chain_list* lofigchain,*newlofigchain=NULL;
int buffer_is_better=0, change=1; /*flags*/
chain_list* pred;
chain_list* temp;
buffer=getCellbuffer();
/*no buffer in library*/
if (!buffer) return 0;
if (!losig->NAMECHAIN) {
fprintf(stderr,"insert_buffer: no name on signal\n");
autexit(1);
}
best_delay=critical_delay(lofig);
init_capa=getcapacitance(losig->NAMECHAIN->DATA);
/*add buffer to netlist*/
signame=getautoname(losig->NAMECHAIN->DATA);
namechain=addchain(NULL,signame);
losig_buf=addlosig(lofig,index,namechain,INTERNAL);
putcapacitance(signame,0);
putdelay(signame,0);
model=getlofig(buffer->BEFIG->NAME,'A');
/*search vdd and vss*/
for (locon=lofig->LOCON; locon; locon=locon->NEXT) {
if (isvdd(locon->NAME)) losig_vdd=locon->SIG;
if (isvss(locon->NAME)) losig_vss=locon->SIG;
}
/*build list of signal*/
for (locon=model->LOCON;locon; locon=locon->NEXT) {
if (locon->DIRECTION==UNKNOWN) {
fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n",
locon->NAME,model->NAME);
autexit(1);
}
if (isvdd(locon->NAME)) losig_aux=losig_vdd;
else if (isvss(locon->NAME)) losig_aux=losig_vss;
else if (locon->DIRECTION==OUT) losig_aux=losig_buf;
else if (locon->DIRECTION==IN) losig_aux=losig;
else {
fprintf(stderr,"insert_buffer: buffer port '%s' unknown\n",locon->NAME);
autexit(1);
}
sigchain=addchain(sigchain,losig_aux);
}
sigchain=reverse(sigchain);
loins_buf=addloins(lofig,signame,model,sigchain);
freechain(sigchain);
/*to check changes*/
init_delay=getdelay(losig->NAMECHAIN->DATA);
init_capa=getcapacitance(losig->NAMECHAIN->DATA);
loins_capacitance(loins_buf,1/*add capa*/);
/*lofigchain*/
for (locon=loins_buf->LOCON;locon; locon=locon->NEXT) {
if (locon->DIRECTION==UNKNOWN) {
fprintf(stderr,"BEH: 'linkage %s' in figure '%s' isn't accepted\n",
locon->NAME,loins_buf->INSNAME);
autexit(1);
}
if (isvdd(locon->NAME)) losig_aux=losig_vdd;
else if (isvss(locon->NAME)) losig_aux=losig_vss;
else if (locon->DIRECTION==OUT) losig_aux=losig_buf;
else if (locon->DIRECTION==IN) losig_aux=losig;
else {
fprintf(stderr,"insert_buffer: buffer port '%s' unknown\n",locon->NAME);
autexit(1);
}
ptype=getptype(losig_aux->USER,LOFIGCHAIN);
if (!ptype) losig_aux->USER=addptype(losig_aux->USER,LOFIGCHAIN,addchain(NULL,locon));
else ptype->DATA=addchain(ptype->DATA,locon);
}
/*move all instance after buffer*/
ptype=getptype(losig->USER,LOFIGCHAIN);
buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN);
if (!ptype || !buffer_ptype) {
fprintf(stderr,"insert_buffer: LOFIGCHAIN not found\n");
autexit(1);
}
for (lofigchain=((chain_list*)ptype->DATA)->NEXT/*first is entry of buffer*/;
lofigchain; lofigchain=lofigchain->NEXT) {
locon=(locon_list*) lofigchain->DATA;
if (locon->DIRECTION==UNKNOWN) {
fprintf(stderr,"BEH: 'linkage %s' isn't accepted\n",
locon->NAME);
autexit(1);
}
/*do not move drivers and port of circuit*/
if (locon->TYPE==EXTERNAL || locon->DIRECTION!=IN) {
newlofigchain=addchain(newlofigchain,locon);
continue;
}
loins=locon->ROOT;
/*change capacitance*/
loins_capacitance(loins,0/*remove capa*/);
/*change netlist*/
locon->SIG=losig_buf;
buffer_ptype->DATA=addchain(buffer_ptype->DATA,locon);
loins_capacitance(loins,1/*add capa*/);
}
/*put back drivers*/
freechain(((chain_list*)ptype->DATA)->NEXT/*first is entry of buffer*/);
((chain_list*)ptype->DATA)->NEXT=newlofigchain;
/*eval all changes*/
propagate_loins_delay(loins_buf);
/*relaxation algorithm*/
while (change) {
change=0;
pred=NULL;
buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN);
ptype=getptype(losig->USER,LOFIGCHAIN);
if (!buffer_ptype || !buffer_ptype->DATA) {
fprintf(stderr,"insert_buffer: LOFIGCHAIN is empty\n");
autexit(1);
}
/*put critical path before buffer*/
for (lofigchain=buffer_ptype->DATA; lofigchain->NEXT/*last is buffer output*/;
lofigchain=lofigchain->NEXT) {
locon=lofigchain->DATA;
loins=locon->ROOT;
/*change capacitance*/
loins_capacitance(loins,0/*remove capa*/);
/*change netlist*/
locon->SIG=losig;
ptype->DATA=addchain(ptype->DATA,locon);
loins_capacitance(loins,1/*add capa*/);
/*put over*/
if (pred) pred->NEXT=lofigchain->NEXT;
else buffer_ptype->DATA=lofigchain->NEXT;
/*eval all changes*/
propagate_loins_delay(loins);
propagate_loins_delay(loins_buf);
delay=critical_delay(lofig);
if (delay<best_delay) {
/*finish change*/
best_delay=delay;
change=1; /*flag of change*/
buffer_is_better=1;
lofigchain->NEXT=NULL;
freechain(lofigchain);
break;
}
else {
/*remove change*/
if (pred) pred->NEXT=lofigchain;
else buffer_ptype->DATA=lofigchain;
/*unchange capacitance*/
loins_capacitance(loins,0/*remove capa*/);
/*unchange netlist*/
locon->SIG=losig_buf;
temp=ptype->DATA;
ptype->DATA=temp->NEXT;
temp->NEXT=NULL;
freechain(temp);
loins_capacitance(loins,1/*add capa*/);
/*avoid change*/
propagate_loins_delay(loins_buf);
propagate_loins_delay(loins);
/*for next loop*/
pred=lofigchain;
}
}
}/*end of while*/
if (buffer_is_better) {
/*chose the best buffer*/
change_instance(loins_buf, losig_buf, lofig, optim_level);
}
else { /*if insert buffer is worst than before, remove it*/
/*remove all references of buffer in lofigchain*/
for (locon=loins_buf->LOCON; locon; locon=locon->NEXT) {
losig_aux=locon->SIG;
ptype=getptype(losig_aux->USER,LOFIGCHAIN);
if (!ptype) break;
pred=NULL;
for (lofigchain=ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) {
if (lofigchain->DATA==locon) {
if (pred) pred->NEXT=lofigchain->NEXT;
else ptype->DATA=lofigchain->NEXT;
lofigchain->NEXT=NULL;
freechain(lofigchain);
break;
}
pred=lofigchain;
}
}
buffer_ptype=getptype(losig_buf->USER,LOFIGCHAIN);
ptype=getptype(losig->USER,LOFIGCHAIN);
if (buffer_ptype) {
for (lofigchain=buffer_ptype->DATA; lofigchain; lofigchain=lofigchain->NEXT) {
locon=lofigchain->DATA;
loins=locon->ROOT;
/*change capacitance*/
loins_capacitance(loins,0/*remove capa*/);
/*change netlist*/
locon->SIG=losig;
ptype->DATA=addchain(ptype->DATA,locon);
loins_capacitance(loins,1/*add capa*/);
propagate_loins_delay(loins);
}
freechain(buffer_ptype->DATA);
buffer_ptype->DATA=NULL;
}
loins_capacitance(loins_buf,0/*remove capa*/);
dellosig(lofig,index);
delloins(lofig,loins_buf->INSNAME);
propagate_losig_delay(losig);
/*verify no change on timing*/
delay=critical_delay(lofig);
capa=getcapacitance(losig->NAMECHAIN->DATA);
//01/09/2004 xtof's modification: rounding problem
if ((int)(capa + 0.5)!=(int)(init_capa + 0.5) || (int)(delay + 0.5)!=(int)(best_delay + 0.5)
|| (int)(init_delay + 0.5)!=(int)(getdelay(losig->NAMECHAIN->DATA) + 0.5)) {
fprintf(stderr,
"insert_buffer: compute error %e!=%e fF %f!=%f ps %f!=%f ps\n",
capa,init_capa,delay,best_delay, init_delay, getdelay(losig->NAMECHAIN->DATA));
autexit(1);
}
}
return buffer_is_better;
}
static int change_instance(loins_list* loins, losig_list* losig, lofig_list* lofig, int optim_level)
{
losig_list* losig_aux;
lofig_list* lofig_aux;
double critical, best_critical, delay, best_delay;
double RC_max, T_max;
locon_list* locon, *locon_aux;
int change=0;
cell_list* cell, *best;
best=getCell(loins->FIGNAME);
if (!best || best->NAME!=loins->FIGNAME) {
fprintf(stderr,"library error: no cell '%s.vbe' found\n",loins->FIGNAME);
autexit(1);
}
if (!losig->NAMECHAIN) {
fprintf(stderr,"change_instance: no name on signal\n");
autexit(1);
}
best_critical=critical_delay(lofig);
best_delay=loins_delay(loins,losig->NAMECHAIN->DATA);
/*compare RC and delay of instance*/
RC_max=loins_max_RC(loins,losig->NAMECHAIN->DATA);
T_max=loins_max_T(loins);
/*check all cell of the same kind*/
for (cell=sameCells(loins->FIGNAME); cell; cell=cell->NEXT) {
/*eval critical*/
loins_capacitance(loins,0); /*remove own capacity*/
loins->FIGNAME=cell->NAME; /*change cell*/
loins_capacitance(loins,1); /*add its own capacity (cell has changed)*/
propagate_loins_delay(loins);
critical=critical_delay(lofig);
delay=loins_delay(loins,losig->NAMECHAIN->DATA);
/*take new solution?*/
if (
(critical<best_critical && (cell->AREA<=best->AREA || optim_level>OPTIM_DELAY0))
|| (critical==best_critical && delay<best_delay && (cell->AREA<=best->AREA || optim_level>=OPTIM_DELAY4 || (RC_max>T_max && optim_level>=OPTIM_DELAY1)))
|| (critical==best_critical && delay==best_delay && cell->AREA<best->AREA)
) {
best_critical=critical;
best=cell;
best_delay=delay;
change=1;
}
} /*end of loop on cell*/
loins_capacitance(loins,0); /*substract own capacity*/
loins->FIGNAME=best->NAME;
/*capacitance and critical delay*/
loins_capacitance(loins,1); /*add it own capacity (cell has changed)*/
propagate_loins_delay(loins);
/*verify change of loins*/
critical=critical_delay(lofig);
delay=loins_delay(loins,losig->NAMECHAIN->DATA);
if ((int)critical!=(int)best_critical || (int)delay!=(int)best_delay) {
fprintf(stderr,
"change_instance: compute error %f!=%f ps %f!=%f ps (%sdue to caller)\n",
critical,best_critical,delay,best_delay,change?"not ":"");
autexit(1);
}
/*if cell doesn't exist but is composed by several cells*/
/*map port with real order*/
if (best->MODE=='A' || best->MODE=='a') {
loins_capacitance(loins,0); /*substract own capacity*/
/*change names*/
loins->FIGNAME=best->BEFIG->NAME;
lofig_aux=getlofig(best->NAME,'A');
for (locon=loins->LOCON; locon; locon=locon->NEXT) {
/*search locon in model*/
for (locon_aux=lofig_aux->LOCON; locon_aux; locon_aux=locon_aux->NEXT){
if (locon->NAME==locon_aux->NAME) break;
}
if (!locon_aux) {
fprintf(stderr,"change_instance: locon '%s' not found\n",
locon->NAME);
autexit(1);
}
losig_aux=locon_aux->SIG;
/*search real connection*/
for (locon_aux=lofig_aux->LOINS->LOCON; locon_aux;
locon_aux=locon_aux->NEXT){
if (losig_aux==locon_aux->SIG) break;
}
if (!locon_aux) {
fprintf(stderr,"change_instance: locon '%s' not found in cell\n",
locon->NAME);
autexit(1);
}
locon->NAME=locon_aux->NAME;
}
/*capacitance and critical delay*/
loins_capacitance(loins,1); /*add it own capacity (cell has changed)*/
propagate_loins_delay(loins);
/*verify change of loins*/
critical=critical_delay(lofig);
delay=loins_delay(loins,losig->NAMECHAIN->DATA);
if ((int)critical!=(int)best_critical || (int)delay!=(int)best_delay) {
fprintf(stderr,
"change_instance: flatten error %f!=%f ps %f!=%f ps\n",
critical,best_critical,delay,best_delay);
autexit(1);
}
} /*end of change loins*/
return change;
}
int main(int argc, char **argv)
{
lofig_list *f;
char *filein=NULL, *fileout=NULL;
int i,j;
int opt=0;
if (argc<2) {
printusage();
exit(1);
}
mbkenv();
for (i=1; i<argc; i++)
if (argv[i][0]=='-')
for (j=1; argv[i][j]!='\0'; j++) {
switch (argv[i][j]) {
case 'a':
opt|=ADDSIG;
break;
case 'n':
opt|=NOALIM;
break;
case 'g':
opt|=NOLOGEN;
break;
case 'r':
opt|=RENINS;
break;
case 'v':
opt|=VSTDRV;
break;
case 'c':
opt|=VECCON;
break;
case 'm':
opt|=MBKDRV;
break;
case 'u':
opt|=NOVECT;
break;
default:
fprintf(stderr, "** Unknown option -%c\n", argv[i][1]);
printusage();
exit(2);
}
}
else
if (!filein)
filein=argv[i];
else
if (!fileout)
fileout=argv[i];
else {
fputs("** Too many filenames\n", stderr);
printusage();
exit(4);
}
if (!filein) {
fputs("** Filename expected!\n", stderr);
printusage();
exit(3);
}
f=getlofig(filein,'A');
guessextdir(f);
if (opt & NOALIM)
removepowers(f);
if (opt & RENINS)
renameinstance(f);
if (opt & NOLOGEN)
removelogen(f);
#if 0
if (opt & VECCON) {
vectlocon(f);
sortlocon(&f->LOCON);
f->LOCON=(locon_list *)reverse(f->LOCON);
}
#endif
if (fileout)
f->NAME=namealloc(fileout);
if (!(opt & NOVECT))
vectlosig(&f->LOSIG);
if (opt & MBKDRV)
savelofig(f);
else {
if (opt&VSTDRV)
vhdlsavevelofig(f, 0);
else if (opt&ADDSIG)
vhdlsavevelofig(f, 1);
else
vhdlsavevelofig(f, 2);
}
#if 0
#ifdef VEL_DEBUG
f->NAME=namealloc("netlist");
vhdlsavevelofig(f,1);
#endif
#endif
exit(0);
}
