distrib/sources/yagle/fcl/fcl_util.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   Alliance                     */
   4 /*                                                                          */
   5 /*    Produit : FCL  v1.02                                                  */
   6 /*    Fichier : fcl_util.c                                                  */
   7 /*                                                                          */
   8 /*    (c) copyright 1996 Laboratoire MASI equipe CAO & VLSI                 */
   9 /*    Tous droits reserves                                                  */
  10 /*    Support : e-mail alliance-support@asim.lip6.fr                        */
  11 /*                                                                          */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 #include "fcl_headers.h"
  16
  17 void fclExit()
  18 {
  19     EXIT(1);
  20 }
  21
  22 fcl_label      CountChain(pthead)
  23 chain_list *pthead;
  24 {
  25     chain_list *pt;
  26     fcl_label      i = 0;
  27
  28     for(pt=pthead;pt;pt=pt->NEXT,i++);
  29
  30     return ((fcl_label) i);
  31 }
  32
  33 fcl_label getlabellocon(ptlocon)
  34 locon_list *ptlocon;
  35 {
  36    if (ptlocon == NULL) return (fcl_label)0;
  37    if (ptlocon->TYPE == 'T') {
  38        if (ptlocon->NAME == MBK_GRID_NAME) return (fcl_label)POID_GRID;
  39        if (ptlocon->NAME == MBK_SOURCE_NAME) return (fcl_label)POID_SOURCE;
  40        if (ptlocon->NAME == MBK_DRAIN_NAME) return (fcl_label)POID_DRAIN;
  41        if (ptlocon->NAME == MBK_BULK_NAME) return (fcl_label)POID_BULK;
  42    }
  43    if (ptlocon->TYPE != INTERNAL) return (fcl_label)POID_PAD;
  44    if (ptlocon->FLAGS != 0) return (fcl_label)ptlocon->FLAGS;
  45
  46    return (fcl_label)POID_INS;
  47 }
  48
  49 fcl_label getlabeltrs(ptlotrs)
  50 lotrs_list *ptlotrs;
  51 {
  52    ptype_list *ptype;
  53
  54    ptype = getptype(ptlotrs->USER,(long)FCL_LABEL_PTYPE);
  55
  56    if (ptype == (ptype_list *) NULL)
  57       return ((fcl_label) 1);
  58
  59    return ((fcl_label) (long)ptype->DATA);
  60 }
  61
  62 fcl_label getlabelsig(ptlosig)
  63 losig_list *ptlosig;
  64 {
  65    ptype_list *ptype;
  66
  67    ptype = getptype(ptlosig->USER,(long)FCL_LABEL_PTYPE);
  68
  69    if (ptype == (ptype_list *) NULL)
  70       return ((fcl_label) 0);
  71
  72    return ((fcl_label) (long)ptype->DATA);
  73 }
  74
  75 void
  76 fclCorruptLotrs(ptlotrs)
  77     lotrs_list *ptlotrs;
  78 {
  79     ptype_list *ptuser;
  80
  81     if ((ptuser = getptype(ptlotrs->USER, FCL_LABEL_PTYPE)) != NULL) {
  82         ptuser->DATA = (void *)FCL_CORRUPT;
  83     }
  84     else {
  85         ptlotrs->USER = addptype(ptlotrs->USER, FCL_LABEL_PTYPE, (void *)FCL_CORRUPT);
  86     }
  87 }
  88
  89 void
  90 fclCorruptLosig(ptlosig)
  91     losig_list *ptlosig;
  92 {
  93     ptype_list *ptuser;
  94
  95     if ((ptuser = getptype(ptlosig->USER, FCL_LABEL_PTYPE)) != NULL) {
  96         ptuser->DATA = (void *)FCL_CORRUPT;
  97     }
  98     else {
  99         ptlosig->USER = addptype(ptlosig->USER, FCL_LABEL_PTYPE, (void *)FCL_CORRUPT);
 100     }
 101 }
 102
 103 fcl_label getlabelsigtrs(ptlotrs,ptlosig)
 104 lotrs_list *ptlotrs;
 105 losig_list *ptlosig;
 106 {
 107    if (ptlotrs->DRAIN->SIG == ptlosig)
 108       return getlabellocon(ptlotrs->DRAIN);
 109
 110    if (ptlotrs->GRID->SIG == ptlosig)
 111       return getlabellocon(ptlotrs->GRID);
 112
 113    if (ptlotrs->SOURCE->SIG == ptlosig)
 114       return getlabellocon(ptlotrs->SOURCE);
 115
 116    if (ptlotrs->BULK) {
 117        if (ptlotrs->BULK->SIG == ptlosig)
 118           return getlabellocon(ptlotrs->BULK);
 119    }
 120
 121    return 0;
 122 }
 123
 124 lotrs_list *whichtrs(ptlofig,ptlocon)
 125 lofig_list *ptlofig;
 126 locon_list *ptlocon;
 127 {
 128     lotrs_list *ptr;
 129
 130     for(ptr=ptlofig->LOTRS;ptr;ptr=ptr->NEXT)
 131     {
 132        if (ptr->DRAIN  == ptlocon) return ptr;
 133        if (ptr->SOURCE == ptlocon) return ptr;
 134        if (ptr->GRID   == ptlocon) return ptr;
 135        if (ptr->BULK   == ptlocon) return ptr;
 136     }
 137
 138     return (lotrs_list *) NULL;
 139 }
 140
 141 void
 142 fclMarkTrans(transchain)
 143     chain_list *transchain;
 144 {
 145     chain_list *ptchain;
 146     lotrs_list *pttrans;
 147     ptype_list *ptuser;
 148
 149     for (ptchain = transchain; ptchain; ptchain = ptchain->NEXT) {
 150         pttrans = (lotrs_list *)ptchain->DATA;
 151         if ((ptuser = getptype(pttrans->USER, FCL_MARK_PTYPE)) != NULL) {
 152             ptuser->DATA  = (void *)((long)ptuser->DATA | FCL_USED);
 153         }
 154         else pttrans->USER = addptype(pttrans->USER, FCL_MARK_PTYPE, (void *)FCL_USED);
 155     }
 156 }
 157
 158 void
 159 fclUnmarkTrans(transchain)
 160     chain_list *transchain;
 161 {
 162     chain_list *ptchain;
 163     lotrs_list *pttrans;
 164     long        mark;
 165
 166     for (ptchain = transchain; ptchain; ptchain = ptchain->NEXT) {
 167         pttrans = (lotrs_list *)ptchain->DATA;
 168         mark = (long)getptype(pttrans->USER, FCL_MARK_PTYPE)->DATA;
 169         mark &= ~FCL_USED;
 170         if (mark == 0) pttrans->USER = delptype(pttrans->USER, FCL_MARK_PTYPE);
 171     }
 172 }
 173
 174 void
 175 fclCleanShareMarks(ptlofig)
 176     lofig_list *ptlofig;
 177 {
 178     lotrs_list *ptlotrs;
 179     loins_list *ptloins;
 180
 181     for (ptlotrs = ptlofig->LOTRS; ptlotrs; ptlotrs = ptlotrs->NEXT) {
 182         if (getptype(ptlotrs->USER, FCL_MARK_PTYPE) != NULL) {
 183             ptlotrs->USER = delptype(ptlotrs->USER, FCL_MARK_PTYPE);
 184         }
 185     }
 186     for (ptloins = ptlofig->LOINS; ptloins; ptloins = ptloins->NEXT) {
 187         if (getptype(ptloins->USER, FCL_MARK_PTYPE) != NULL) {
 188             ptloins->USER = delptype(ptloins->USER, FCL_MARK_PTYPE);
 189         }
 190     }
 191 }
 192
 193 void
 194 fclCleanTransferMarks(ptlofig)
 195     lofig_list *ptlofig;
 196 {
 197     ptype_list *ptuser;
 198     lotrs_list *ptlotrs;
 199     loins_list *ptloins;
 200     losig_list *ptlosig;
 201
 202     for (ptlotrs = ptlofig->LOTRS; ptlotrs; ptlotrs = ptlotrs->NEXT) {
 203         if (getptype(ptlotrs->USER, FCL_TRANSFER_PTYPE) != NULL) {
 204             ptlotrs->USER = delptype(ptlotrs->USER, FCL_TRANSFER_PTYPE);
 205         }
 206     }
 207     for (ptloins = ptlofig->LOINS; ptloins; ptloins = ptloins->NEXT) {
 208         if (getptype(ptloins->USER, FCL_TRANSFER_PTYPE) != NULL) {
 209             ptloins->USER = delptype(ptloins->USER, FCL_TRANSFER_PTYPE);
 210         }
 211     }
 212     for (ptlosig = ptlofig->LOSIG; ptlosig; ptlosig = ptlosig->NEXT) {
 213         if (getptype(ptlosig->USER, FCL_TRANSFER_PTYPE) != NULL) {
 214             ptlosig->USER = delptype(ptlosig->USER, FCL_TRANSFER_PTYPE);
 215         }
 216     }
 217     if ((ptuser = getptype(ptlofig->USER, FCL_LOCON_PTYPE)) != NULL) {
 218         freechain((chain_list *)ptuser->DATA);
 219         ptlofig->USER = delptype(ptlofig->USER, FCL_LOCON_PTYPE);
 220     }
 221 }
 222
 223 void
 224 fclCleanCouplingMarks(ptlofig)
 225     lofig_list *ptlofig;
 226 {
 227     losig_list *ptlosig;
 228     ptype_list *ptuser;
 229
 230     for (ptlosig = ptlofig->LOSIG; ptlosig; ptlosig = ptlosig->NEXT) {
 231         if ((ptuser = getptype(ptlosig->USER, FCL_COUP_LIST_PTYPE)) != NULL) {
 232             freenum((num_list *)ptuser->DATA);
 233             ptlosig->USER = delptype(ptlosig->USER, FCL_COUP_LIST_PTYPE);
 234         }
 235     }
 236 }
 237
 238 void fclCleanTransList(ptloins)
 239     loins_list *ptloins;
 240 {
 241     ptype_list *ptuser;
 242
 243     if ((ptuser = getptype(ptloins->USER, FCL_TRANSLIST_PTYPE)) != NULL) {
 244         freechain((chain_list *)ptuser->DATA);
 245         ptloins->USER = delptype(ptloins->USER, FCL_TRANSLIST_PTYPE);
 246     }
 247     if ((ptuser = getptype(ptloins->USER, FCL_INSLIST_PTYPE)) != NULL) {
 248         freechain((chain_list *)ptuser->DATA);
 249         ptloins->USER = delptype(ptloins->USER, FCL_INSLIST_PTYPE);
 250     }
 251
 252 }
 253
 254 void
 255 fclDeleteInstance(ptloins)
 256     loins_list *ptloins;
 257 {
 258     ptype_list *ptuser;
 259     locon_list *ptlocon, *ptnextlocon;
 260
 261     if ((ptuser = getptype(ptloins->USER, FCL_TRANSLIST_PTYPE)) != NULL) {
 262         freechain((chain_list *)ptuser->DATA);
 263         ptloins->USER = delptype(ptloins->USER, FCL_TRANSLIST_PTYPE);
 264     }
 265     if ((ptuser = getptype(ptloins->USER, FCL_INSLIST_PTYPE)) != NULL) {
 266         freechain((chain_list *)ptuser->DATA);
 267         ptloins->USER = delptype(ptloins->USER, FCL_INSLIST_PTYPE);
 268     }
 269     for (ptlocon = ptloins->LOCON; ptlocon; ptlocon = ptnextlocon) {
 270         ptnextlocon = ptlocon->NEXT;
 271         mbkfree(ptlocon);
 272     }
 273     mbkfree(ptloins);
 274 }
 275
 276 void
 277 fclFreeCorrespList(ptlist)
 278     fclcorresp_list *ptlist;
 279 {
 280     fclcorresp_list *ptcorresp;
 281     fclcorresp_list *ptnext;
 282
 283     for (ptcorresp = ptlist; ptcorresp; ptcorresp = ptnext) {
 284         ptnext = ptcorresp->NEXT;
 285         mbkfree(ptcorresp);
 286     }
 287 }
 288
 289 /* display system and user time */
 290 extern long NUM_PTYPE;
 291
 292 void
 293 fclPrintTime(start, end, rstart, rend)
 294     struct rusage  *start, *end;
 295     time_t          rstart, rend;
 296
 297 {
 298     unsigned long   temps;
 299     unsigned long   user, syst;
 300     unsigned long   userM, userS, userD;
 301     unsigned long   systM, systS, systD;
 302     unsigned long   bytes;
 303
 304     temps = rend - rstart;
 305     user = (100 * end->ru_utime.tv_sec + (end->ru_utime.tv_usec / 10000))
 306         - (100 * start->ru_utime.tv_sec + (start->ru_utime.tv_usec / 10000));
 307     syst = (100 * end->ru_stime.tv_sec + (end->ru_stime.tv_usec / 10000))
 308         - (100 * start->ru_stime.tv_sec + (start->ru_stime.tv_usec / 10000));
 309
 310     userM = user / 6000;
 311     userS = (user % 6000) / 100;
 312     userD = (user % 100) / 10;
 313
 314     systM = syst / 6000;
 315     systS = (syst % 6000) / 100;
 316     systD = (syst % 100) / 10;
 317
 318     fprintf(stdout, " %02ldm%02lds", (long) (temps / 60), (long) (temps % 60));
 319     fprintf(stdout, "  u:%02ldm%02ld.%ld", userM, userS, userD);
 320     bytes = mbkprocessmemoryusage();
 321     fprintf(stdout, "  M:%ldKb\n", bytes / 1024);
 322     fflush(stdout);
 323 }
 324
 325 void
 326 fclChrono(t, rt)
 327     struct rusage  *t;
 328     time_t         *rt;
 329 {
 330     getrusage(RUSAGE_SELF, t);
 331     time(rt);
 332 }
 333
 334