spiceparser/netlist_extract.c

   1 /********************
   2     This file is part of the software library CADLIB written by Conrad Ziesler
   3     Copyright 2003, Conrad Ziesler, all rights reserved.
   4
   5 *************************
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 ******************/
  21 /* extract.c :  optional magic .ext file input (bypassing ext2spice)
  22                 links to magic's extract library
  23                 .ext files have more/better info than what's in the spice file,
  24                 which gives us better debugging info, and integration with the layout
  25
  26 Conrad Ziesler
  27 */
  28
  29
  30 /* this is loosely based on magic's extcheck sample program,
  31    and links to the magic libraries, so if you don't have them, undef USE_EXTRACT_FORMAT
  32
  33    the following copyright notice was from extcheck.c, which this code was based on
  34
  35 */
  36
  37 /*
  38  * extcheck.c --
  39  *
  40  *     *********************************************************************
  41  *     * Copyright (C) 1985, 1990 Regents of the University of California. *
  42  *     * Permission to use, copy, modify, and distribute this              *
  43  *     * software and its documentation for any purpose and without        *
  44  *     * fee is hereby granted, provided that the above copyright          *
  45  *     * notice appear in all copies.  The University of California        *
  46  *     * makes no representations about the suitability of this            *
  47  *     * software for any purpose.  It is provided "as is" without         *
  48  *     * express or implied warranty.  Export of this software outside     *
  49  *     * of the United States of America may require an export license.    *
  50  *     *********************************************************************
  51 */
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61 #include <stdio.h>
  62 #include <math.h>
  63 #include "debug.h"
  64
  65 #include "netlist_extract.h"
  66
  67 #ifndef __NETLIST_H__
  68 #include "netlist.h"
  69 #endif
  70
  71
  72
  73 void *mymalloc(unsigned size)
  74 {
  75   return malloc(size);
  76 }
  77
  78
  79 #define CHECK_EXTINIT(g)  if(g!=NULL) if(g->input.generic->magic==EXTRACT_MAGIC) if(g->input.ext->did_EF_init_read)
  80
  81 #ifdef USE_EXTRACT_FORMAT
  82
  83
  84
  85
  86 #include <stdio.h>
  87 #include <ctype.h>
  88 #include <varargs.h>
  89
  90 #include "include/magic.h"
  91 #include "include/paths.h"
  92 #include "include/geometry.h"
  93 #include "include/hash.h"
  94 #include "include/utils.h"
  95 #include "include/pathvisit.h"
  96 #include "include/extflat.h"
  97 #include "include/runstats.h"
  98
  99
 100 int GeoScale(Transform *t);
 101 void EFInit(void);
 102 void EFReadFile(char *name);
 103 void EFFlatBuild(char *rootName, int flags);
 104 void EFFlatDone(void);
 105 void EFVisitFets(
 106                  int (*fetProc)(Fet *fet, HierName *hname, Transform *t, int l , int w, ClientData data),
 107                  ClientData cdata
 108                  );
 109
 110 void EFVisitNodes(
 111                   int (*nodeProc)(EFNode *node, int r, double c, ClientData cdata),
 112                   ClientData cdata
 113                   );
 114
 115 bool EFHNIsGlob(HierName *hname);
 116 char * EFHNToStr(HierName *hierName);
 117
 118 void EFDone(void);
 119
 120
 121 static int ecNumFets;
 122 static int ecNumCaps;
 123 static int ecNumResists;
 124 static int ecNumThreshCaps;
 125 static int ecNumThreshResists;
 126 static int ecNumNodes;
 127 static int ecNumGlobalNodes;
 128 static int ecNumNodeCaps;
 129 static int ecNumNodeResists;
 130
 131
 132
 133 #endif
 134
 135
 136 /*
 137    make a new extract_t container
 138    first create fake argc, *argv[] using extract options from config file
 139 */
 140
 141 #ifdef USE_EXTRACT_FORMAT
 142 extract_t *extract_new(char *rootname)
 143 {
 144   extract_t *p;
 145   int i;
 146   assert(rootname!=NULL);
 147   p=mymalloc(sizeof(extract_t)+(sizeof(char*)*(PARAMS.extract_qty+4)));
 148   assert(p!=NULL);
 149   memset(p,0,sizeof(extract_t));
 150   p->root=strdup(rootname);
 151   assert(p->root!=NULL);
 152   p->extract_magic=EXTRACT_MAGIC;
 153   p->ext_argv=(char **) (&p[1]);
 154   p->ext_argv[0]="ext2spice";
 155   for(i=1;i< (PARAMS.extract_qty+1);i++)
 156     p->ext_argv[i]=PARAMS.extract_params[i-1];
 157   p->ext_argv[i]=p->root;
 158   p->ext_argv[i+1]=NULL;
 159   p->ext_argc=i+1;
 160   p->did_EF_init_read=0;
 161
 162
 163
 164   /* Process command line arguments */
 165   EFInit();
 166   p->fname = EFArgs(p->ext_argc, p->ext_argv, (int (*)()) NULL, (ClientData) NULL);
 167   if(p->fname==NULL){ fprintf(stderr,"ERROR: extract configuration  error\n"); return NULL; }
 168
 169   /* Read the hierarchical description of the input circuit */
 170   EFReadFile(p->fname);
 171
 172   if(PARAMS.extfix!=NULL) /* tag with extfix data (merge Gnd/Vdd GND/VDD) */
 173     EFReadFile(PARAMS.extfix);
 174
 175   if (EFArgTech) EFTech = StrDup((char **) NULL, EFArgTech);
 176   if (EFScale==0) EFScale = 1;
 177   p->did_EF_init_read=1;
 178
 179   if(0)
 180     {
 181       fprintf(stderr,"EXT: %i layers defined\n",EFLayerNumNames);
 182       for(i=0;i<EFLayerNumNames;i++)
 183         fprintf(stderr,"EXT: layer %i=%s\n",i,EFLayerNames[i]);
 184     }
 185
 186
 187
 188   return p;
 189 }
 190
 191 #else
 192
 193 extract_t *extract_new(char *rootname)
 194 {
 195   return NULL;
 196 }
 197 #endif
 198
 199
 200
 201 #ifndef USE_EXTRACT_FORMAT
 202
 203
 204 /****************** LINK TO MAGIC EXTFLAT LIBRARY ************/
 205 #else
 206
 207
 208
 209
 210 void extract_finish(graph_t *gr)
 211 {
 212
 213   EFFlatDone();
 214   EFDone();
 215
 216   fprintf(stderr,"EXT: Memory used: %s\n", RunStats(RS_MEM, NULL, NULL));
 217   fprintf(stderr,"EXT: %d fets\n", ecNumFets);
 218   fprintf(stderr,"EXT: %d nodes (%d global, %d local)\n",
 219           ecNumNodes, ecNumGlobalNodes, ecNumNodes - ecNumGlobalNodes);
 220   fprintf(stderr,"EXT: %d nodes above capacitance threshold\n", ecNumNodeCaps);
 221   fprintf(stderr,"EXT: %d nodes above resistance threshold\n", ecNumNodeResists);
 222   fprintf(stderr,"EXT: %d internodal capacitors (%d above threshold)\n",
 223           ecNumCaps, ecNumThreshCaps);
 224   fprintf(stderr,"EXT: %d explicit resistors (%d above threshold)\n",
 225           ecNumResists, ecNumThreshResists);
 226 }
 227
 228 static int countfetVisit(Fet *fet, HierName *hname, Transform *t, int l , int w, ClientData data)
 229 {
 230   fet->fet_type&=0x07f; /* clear our sneaky bit */
 231   ecNumFets++;
 232   return 0;
 233 }
 234
 235
 236 static int countnodeVisit(EFNode *node, int res, double cap, ClientData data)
 237 {
 238   ecNumNodes++;
 239   return 0;
 240 }
 241
 242 static EFNode *GetNode(HierName *prefix,HierName *suffix)
 243 {
 244   HashEntry *he;
 245
 246   he = EFHNConcatLook(prefix, suffix, "output");
 247   return(((EFNodeName *) HashGetValue(he))->efnn_node);
 248 }
 249
 250
 251 void extract_setup_graph(graph_t *gr)
 252 {
 253   int er=1;
 254   CHECK_EXTINIT(gr)er=0;
 255   assert(!er);
 256
 257   /* Convert the hierarchical description to a flat one */
 258   EFFlatBuild(gr->input.ext->fname, EF_FLATNODES | EF_FLATCAPS | EF_FLATRESISTS);
 259
 260   ecNumFets=0;
 261   ecNumNodes=0;
 262   EFVisitFets(countfetVisit, (void *) gr);
 263   EFVisitNodes(countnodeVisit, (void *) gr);
 264   gr->mge=ecNumFets;
 265   gr->mgn=ecNumNodes;
 266
 267   fprintf(stderr,"EXT: setup %i fets %i nodes\n",gr->mge, gr->mgn);
 268 }
 269
 270
 271
 272
 273 static int buildnodeVisit(EFNode *node, int res, double cap, ClientData data)
 274 {
 275   graph_t *g=(void *)data;
 276   hashchain_t *hc;
 277   hashload_t pay;
 278   char *str;
 279   gn_t *gn;
 280   int i;
 281   PerimArea *diff[2];
 282
 283   /*
 284      cap = (cap + 500) / 1000;
 285      res = (res + 500) / 1000;
 286      what's up with this?
 287   */
 288
 289   assert(node!=NULL);
 290   assert(node->efnode_name!=NULL);
 291   str=EFHNToStr(node->efnode_name->efnn_hier);
 292
 293   ecNumNodes++;
 294   if (EFHNIsGlob(node->efnode_name->efnn_hier)) ecNumGlobalNodes++;
 295
 296   pay.flag=PAYLOAD_node;
 297   pay.data=gn=new_gn(g);
 298   node->efnode_client=(void *)gn; /* store our node ptr in here so we don't have to compare strings */
 299   hc=add_hashtab(g->names,str,pay);  /* add some string data for debugging, printing, etc memory hog*/
 300   if(EFHNIsGlob(node->efnode_name->efnn_hier))
 301     {
 302       int l;
 303       gn->special=safestrdup(hc->str);
 304       l=strlen(gn->special);
 305       if(gn->special[l-1]=='!')gn->special[l-1]=0;
 306     }
 307   else gn->special=NULL;
 308   gn->name=hc->str;
 309   gn->debug=gn->name;
 310   gn->wtotal=0;
 311
 312   gn->cfixed=cap*1e-18; /* cap in attofarrads 1e-18 */
 313   diff[FTpfet]=node->efnode_pa+1;  /* resist class 1 from techfile is pdiff */
 314   diff[FTnfet]=node->efnode_pa+0;  /* resist class 0 from techfile is ndiff */
 315
 316   for(i=0;i<2;i++)
 317     gn->cdiff[i]=
 318       (PARAMS.scale * PARAMS.scale * diff[i]->pa_area * PARAMS.c_area_sd[i]) +
 319       (PARAMS.scale * diff[i]->pa_perim * PARAMS.c_perim_sd[i])
 320       ;
 321
 322   /*
 323     note on capacitance:
 324     The above code is very dependent on the magic techfile extract section,
 325     namely, it assumes a specific resistance class ordering
 326     and it assumes the extractor doesn't sum up diffusion and gate capacitance
 327   */
 328
 329   return 0;
 330 }
 331
 332 static graph_t *extract_Graph;
 333
 334 static int buildfetVisit(Fet *fet, HierName *hname, Transform *t, int l , int w, ClientData data)
 335 {
 336   ge_t *ep;
 337   FetTerm *gate, *source, *drain;
 338   EFNode /* *bnode,*/  *snode, *dnode, *gnode;
 339   Rect r;
 340   int      scale;
 341   graph_t *gr=extract_Graph;
 342   int typ;
 343   char *ft;
 344   double sc=PARAMS.scale; /* lamda in meters */
 345
 346   assert(sc>0);
 347   assert(fet!=NULL);
 348
 349   gate = &fet->fet_terms[0];
 350   source = drain = &fet->fet_terms[1];
 351   if (fet->fet_nterm >= 3)
 352     drain = &fet->fet_terms[2];
 353
 354   gnode = GetNode (hname, gate->fterm_node->efnode_name->efnn_hier);
 355   snode = GetNode (hname, source->fterm_node->efnode_name->efnn_hier);
 356   dnode = GetNode (hname, drain->fterm_node->efnode_name->efnn_hier);
 357   /*bnode = fetSubstrate(hname, fet->fet_subsnode->efnode_name->efnn_hier, fet->fet_type, NULL);*/
 358
 359   assert(w!=0);
 360   assert(l!=0);
 361   GeoTransRect(t, &fet->fet_rect, &r);
 362   scale = GeoScale(t);
 363   assert(scale!=0);
 364   typ=fet->fet_type;
 365   ft=EFFetTypes[typ];
 366   typ=np_type((uchar)ft[0]);
 367   ep=new_ge(gr);
 368   ep->type=typ;
 369
 370
 371   ep->flatref.x=r.r_ll.p_x;
 372   ep->flatref.xx=r.r_ur.p_x;
 373   ep->flatref.y=r.r_ll.p_y;
 374   ep->flatref.yy=r.r_ur.p_y;
 375
 376   ep->WL= (PARAMS.gm_woverl[ep->type]*(double)w)/(double)l;
 377   ep->Cg= sc*sc*PARAMS.c_area_gate[ep->type]*((double)w*scale)*((double)l*scale);
 378   ep->Cs=0; /* compute this from ? */
 379   ep->Cd=0; /* same with this */
 380
 381   /* for above Cs,Cd: strategy, split the diffusion resistance classes between all fet s/d's connected
 382      to the node, proportional to the total width of each device
 383      this is better than the hspice version, where diffusion is lumped onto a single fet.
 384      so one poor fet gets all the diffusion for resizing
 385      we have to do this after we visit all the fets once, so node wtotals are updated correctly
 386   */
 387
 388   ep->parent.vp=(void *)fet;
 389   ep->gn[GE_G]=(void *)(gnode->efnode_client);
 390   ep->gn[GE_S]=(void *)(snode->efnode_client);
 391   ep->gn[GE_D]=(void *)(dnode->efnode_client);
 392   if(ep->gn[GE_S] > ep->gn[GE_D] )  /* put source/drain in cannonical order (source is lower node number) */
 393     { void *tmp=ep->gn[GE_S]; ep->gn[GE_S]=ep->gn[GE_D]; ep->gn[GE_D]=tmp; }
 394   ep->gn[GE_S]->wtotal+=(w*scale*sc);
 395   ep->gn[GE_D]->wtotal+=(w*scale*sc);
 396   return 0;
 397 }
 398
 399 /*
 400 static int capVisit(HierName *hn1, HierName *hn2, double cap)
 401 {
 402     ecNumCaps++;
 403     cap = (cap + 500) / 1000;
 404     if (cap > (double) EFCapThreshold) ecNumThreshCaps++;
 405     return 0;
 406 }
 407
 408 static int resistVisit(HierName *hn1, HierName *hn2, int res)
 409 {
 410     ecNumResists++;
 411     res = (res + 500) / 1000;
 412     if (res > EFResistThreshold) ecNumThreshResists++;
 413     return 0;
 414 }
 415 */
 416
 417
 418
 419 static int comparesorted(const void *a, const void *b)
 420 {
 421   const ge_t *pa=a,*pb=b;
 422
 423   if(pa==pb)return 0;
 424   if(pa==NULL)return 1;
 425   if(pb==NULL)return -1;
 426
 427
 428   if(pa->gn[GE_G] > pb->gn[GE_G])return 1;
 429   if(pa->gn[GE_G] < pb->gn[GE_G])return -1;
 430
 431   if( (pa->gn[GE_S]==pb->gn[GE_S]) )
 432     {
 433       if(pa->gn[GE_D] > pb->gn[GE_D] ) return 1;
 434       else if(pa->gn[GE_D] < pb->gn[GE_D] ) return -1;
 435     }
 436   if( (pa->gn[GE_D]==pb->gn[GE_D]) )
 437     {
 438       if(pa->gn[GE_D] > pb->gn[GE_D] ) return 1;
 439       else if(pa->gn[GE_D] < pb->gn[GE_D] ) return -1;
 440     }
 441   else if( (pa->gn[GE_S]==pb->gn[GE_D]) )
 442     {
 443       if(pa->gn[GE_D] > pb->gn[GE_S] ) return 1;
 444       else if(pa->gn[GE_D] < pb->gn[GE_S] ) return -1;
 445     }
 446   else if( (pa->gn[GE_D]==pb->gn[GE_S]) )
 447     {
 448       if(pa->gn[GE_S] > pb->gn[GE_D] ) return 1;
 449       else if(pa->gn[GE_S] < pb->gn[GE_D] ) return -1;
 450     }
 451   else
 452     {
 453       if(pa->gn[GE_S] > pb->gn[GE_S] ) return 1;
 454       else if(pa->gn[GE_S] < pb->gn[GE_S] ) return -1;
 455       assert(0);
 456     }
 457   return 0;
 458 }
 459
 460
 461 static double compute_diffcap(gn_t *np, double w, int type)
 462 {
 463   double ws,c;
 464   ws=np->wtotal;
 465   if(ws<=0.0)assert(0);
 466   c= np->cdiff[type]*w/ws;
 467   return c;
 468 }
 469
 470 void extract_build_graph(graph_t *gr)
 471 {
 472   ge_t *ep,*pep,*wep;
 473   int i,j;
 474   int er=1;
 475   CHECK_EXTINIT(gr)er=0;
 476   assert(!er);
 477
 478   extract_Graph=gr;
 479   EFVisitNodes(buildnodeVisit, (ClientData) gr);
 480   EFVisitFets(buildfetVisit, (ClientData) gr);
 481
 482   /*
 483     if (EFCapThreshold < INFINITE_THRESHOLD)    EFVisitCaps(capVisit, (ClientData) NULL);
 484     if (EFResistThreshold < INFINITE_THRESHOLD) EFVisitResists(resistVisit, (ClientData) NULL);
 485   */
 486
 487   /* now we want to sort the edges to merge duplicate fets faster */
 488   qsort(gr->ge,gr->qge,sizeof(ge_t),comparesorted);
 489
 490   /* mark and merge parallel transistors */
 491   for(i=0,j=0,pep=NULL,ep=gr->ge;i<gr->qge;i++)
 492     {
 493       ep->flag=0;
 494       if(pep!=NULL)
 495         if( (ep->gn[GE_G]==pep->gn[GE_G]) &&
 496             (ep->gn[GE_S]==pep->gn[GE_S]) &&
 497             (ep->gn[GE_D]==pep->gn[GE_D])
 498             ) /* parallel fet, merge */
 499           {
 500             pep->WL+=ep->WL;
 501             pep->Cg+=ep->Cg;
 502             pep->Cs+=ep->Cs;
 503             pep->Cd+=ep->Cd;
 504             ep->flag=1;
 505             j++;
 506           }
 507         else pep=ep;
 508       else pep=ep;
 509
 510       ep++;
 511     }
 512
 513   /* eliminate flagged transistors
 514      wep moves forward for each new good transistor
 515      ep moves forward for each transistor
 516    */
 517
 518   for(j=0,wep=ep=gr->ge,i=0;i<gr->qge;i++)
 519     {
 520       if(!ep->flag) { if(wep!=ep) { *wep=*ep; } j++; wep++; }
 521       ep++;
 522     }
 523
 524   gr->qge=j;
 525
 526
 527   /* now divvy up s/d diffusions between fets */
 528
 529   for(ep=gr->ge,i=0;i<gr->qge;i++)
 530     {
 531       double w;
 532       w=edge_width(ep);
 533       ep->Cs=compute_diffcap(ep->gn[GE_S],w,ep->type);
 534       ep->Cd=compute_diffcap(ep->gn[GE_D],w,ep->type);
 535       ep++;
 536     }
 537
 538 }
 539
 540
 541
 542
 543
 544 #endif /* USE_EXTRACT_FORMAT */
 545
 546
 547
 548
 549
 550