distrib/sources/api/power/power_API_util.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : AVERTEC global tools                                        */
   6 /*    Fichier : power_API_util.c                                            */
   7 /*                                                                          */
   8 /*    © copyright 2009 AVERTEC                                              */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Olivier BICHAUT                                           */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 #include <dirent.h>
  16 #include <stddef.h>
  17 #include <stdio.h>
  18 #include <sys/types.h>
  19 #include <dirent.h>
  20
  21 #include BCK_H
  22 #include STM_H
  23 #include TTV_H
  24 #include MLU_H
  25 #include MUT_H
  26 #include INF_H
  27 #include EFG_H
  28 #include TAS_H
  29 #include TRC_H
  30 #include YAG_H
  31 #include MCC_H
  32 #include INF_H
  33 #include VCD_H
  34 #define API_USE_REAL_TYPES
  35 #include "power_API.h"
  36 #include "power_API_util.h"
  37
  38 void SwitchingPower (TimingFigure *tf)
  39 {
  40     chain_list *chainevents, *chain, *chvcdsig, *ch, *chainsigs, *chsig /*, *chainsigs2, *chsig2 */;
  41     char *signame, *name;
  42     char value, test=1;
  43     ttvsig_list *ttvsig, *prevsig;
  44     ptype_list *ptype, *ptypenodevcdinfo;
  45     ttvline_list *line;
  46     ttvevent_list *node;
  47     timing_model *modmax;
  48     double nrjmax, nrjtime, nrjsig, consototale=0.0;
  49     float slope;
  50     ht *htsig=NULL;
  51     long search;
  52     long slew;
  53     ttvtrans_vcd_power *transvcdpower, *tvp;
  54     FILE *ptf;
  55     ttvnode_vcd_info *ttvnodevcdinfo;
  56
  57     ptf = mbkfopen( "toto4", "dat", WRITE_TEXT );
  58     ttv_disablecache(tf);
  59     vcd_goto_first_time ();
  60     while(test){
  61         chainevents = cdl_get_current_events();
  62         nrjtime = 0.0;
  63         for (chain = chainevents; chain; chain = chain->NEXT){
  64           for (chvcdsig = cdl_geteventsig (chain); chvcdsig; chvcdsig = chvcdsig->NEXT){
  65 //            signame = cdl_geteventsig (chain);
  66             signame = (char*)chvcdsig->DATA;
  67             name = mbk_devect(signame, "(", ")");
  68             signame = ttv_revect(name);
  69             value = cdl_geteventval (chain);
  70             if(value=='0' || value=='1'){
  71                 nrjsig = 0.0;
  72                 chainsigs = ttv_get_signals_from_netname(tf, &htsig, signame);
  73                 for(chsig = chainsigs; chsig; chsig = chsig->NEXT){
  74                     nrjmax = 0.0;
  75                     ttvsig = (ttvsig_list*)chsig->DATA;
  76                     if(!ttvsig) continue;
  77                     ttv_expfigsig (tf, ttvsig, ttvsig->ROOT->INFO->LEVEL, tf->INFO->LEVEL, TTV_STS_DUAL, TTV_FILE_DTX);
  78                     if(value=='0')
  79                         node = &ttvsig->NODE[0];
  80                     else if(value=='1')
  81                         node = &ttvsig->NODE[1];
  82                     if((ptypenodevcdinfo = getptype(node->USER, TTV_NODE_VCD_INFO)) != NULL){
  83                         prevsig = ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->PREVSIG;
  84                     }else{
  85                         prevsig = NULL;
  86                     }
  87                     for(line = node->INLINE; line; line = line->NEXT){
  88                         if(line->NODE->ROOT == prevsig){
  89                             modmax = stm_getmodel( tf->INFO->FIGNAME, line->MDMAX );
  90                             if(modmax){
  91
  92                                 if((ptypenodevcdinfo = getptype(line->NODE->USER, TTV_NODE_VCD_INFO)) != NULL){
  93                                     slope = ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->SLOPE;
  94                                 }else{
  95                                     if( line->TYPE & ( TTV_LINE_F | TTV_LINE_E | TTV_LINE_D ) )
  96                                         search = TTV_FIND_LINE ;
  97                                     else
  98                                         search = TTV_FIND_PATH ;
  99                                     ttv_getnodeslope(tf,NULL,line->NODE, &slew,search);
 100                                     slope = slew/TTV_UNIT;
 101                                 }
 102
 103                                 nrjmax += stm_energy_eval (modmax, ttvsig->CAPA , stm_mod_shrinkslew_thr2scm( modmax, slope ));
 104                             }
 105                         }
 106                     }
 107
 108                     if(nrjmax > 0.0){
 109                         fprintf(ptf,"%ld %s %s %g\n", vcd_get_time(), prevsig->NAME, ttvsig->NAME, nrjmax) ;
 110
 111                         transvcdpower = (ttvtrans_vcd_power *)mbkalloc(sizeof (struct ttvtrans_vcd_power));
 112                         transvcdpower->NEXT = NULL;
 113                         transvcdpower->PREV = NULL;
 114                         transvcdpower->SIG = ttvsig;
 115                         transvcdpower->TIME = vcd_get_time ();
 116                         transvcdpower->NRJ = (float)nrjmax;
 117                         if((ptype = getptype(ttvsig->USER, TTV_SIG_VCDPOWER)) != NULL){
 118                             for(tvp = (ttvtrans_vcd_power*)ptype->DATA; tvp->NEXT; tvp = tvp->NEXT);
 119                             transvcdpower->PREV = tvp;
 120                             tvp->NEXT = transvcdpower;
 121                         }else{
 122                             ttvsig->USER = addptype(ttvsig->USER, TTV_SIG_VCDPOWER, transvcdpower);
 123                         }
 124                         if((ptype = getptype(ttvsig->ROOT->USER, TTV_FIG_VCDPOWER)) != NULL){
 125                             ptype->DATA = (void*)addchain((chain_list *)ptype->DATA, transvcdpower);
 126                         }else{
 127                             ttvsig->ROOT->USER = addptype(ttvsig->ROOT->USER, TTV_FIG_VCDPOWER, addchain(NULL, transvcdpower));
 128                         }
 129                     }
 130
 131                     consototale += nrjmax;
 132                     nrjtime += nrjmax;
 133                     nrjsig += nrjmax;
 134 //                    fprintf(stdout, "%s : %c : %g\n", ttvsig->NAME, value, nrjmax);
 135                 }
 136 //                vcd_add_trans_nrj((trans_list*)chain->DATA, nrjsig);
 137             }
 138           }
 139         }
 140         vcd_add_nrj((float)nrjtime);
 141         for (chain = chainevents; chain; chain = chain->NEXT){
 142           for (chvcdsig = cdl_geteventsig (chain); chvcdsig; chvcdsig = chvcdsig->NEXT){
 143 //            signame = cdl_geteventsig (chain);
 144             signame = (char*)chvcdsig->DATA;
 145             name = mbk_devect(signame, "(", ")");
 146             signame = ttv_revect(name);
 147             value = cdl_geteventval (chain);
 148             if(value=='0' || value=='1'){
 149                 chainsigs = ttv_get_signals_from_netname(tf, &htsig, signame);
 150                 for(chsig = chainsigs; chsig; chsig = chsig->NEXT){
 151                     ttvsig = (ttvsig_list*)chsig->DATA;
 152                     if(!ttvsig) continue;
 153                     ttv_expfigsig (tf, ttvsig, ttvsig->ROOT->INFO->LEVEL, tf->INFO->LEVEL, TTV_STS_DUAL, TTV_FILE_DTX);
 154                     if(value=='0')
 155                         node = &ttvsig->NODE[0];
 156                     else if(value=='1')
 157                         node = &ttvsig->NODE[1];
 158                     ptype = getptype (node->USER, TTV_NODE_DUALLINE);
 159                     if (ptype) {
 160                         for (ch = (chain_list*)ptype->DATA; ch; ch = ch->NEXT) {
 161                             line = (ttvline_list*)ch->DATA;
 162                             if (((line->TYPE & TTV_LINE_U) != TTV_LINE_U) && ((line->TYPE & TTV_LINE_O) != TTV_LINE_O) && ((line->TYPE & TTV_LINE_RC) != TTV_LINE_RC)) {
 163                                 if((ptypenodevcdinfo = getptype(line->ROOT->USER, TTV_NODE_VCD_INFO)) != NULL){
 164                                     if((((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->TIME != vcd_get_time())
 165                                     || ((((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->TIME == vcd_get_time()) && (line->FMAX/TTV_UNIT > ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->SLOPE))){
 166                                         ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->PREVSIG = ttvsig;
 167                                         ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->SLOPE = (float)(line->FMAX/TTV_UNIT);
 168                                         ((ttvnode_vcd_info*)ptypenodevcdinfo->DATA)->TIME = vcd_get_time();
 169                                     }
 170                                 }else{
 171                                     ttvnodevcdinfo = (ttvnode_vcd_info *)mbkalloc(sizeof (struct ttvnode_vcd_info));
 172                                     ttvnodevcdinfo->TIME = vcd_get_time();
 173                                     ttvnodevcdinfo->PREVSIG = ttvsig;
 174                                     ttvnodevcdinfo->SLOPE = (float)(line->FMAX/TTV_UNIT);
 175                                     line->ROOT->USER = addptype(line->ROOT->USER, TTV_NODE_VCD_INFO, ttvnodevcdinfo);
 176                                 }
 177
 178
 179 /*                                chainsigs2 = ttv_get_signals_from_netname(tf, &htsig, line->ROOT->ROOT->NETNAME);
 180                                 for(chsig2 = chainsigs2; chsig2; chsig2 = chsig2->NEXT){
 181                                     if((ptypeprevsig = getptype(((ttvsig_list*)chsig2->DATA)->USER, TTV_SIG_VCD_PREV_SIG)) != NULL){
 182                                         ptypeprevsig->DATA = ttvsig;
 183                                     }else{
 184                                         ((ttvsig_list*)chsig2->DATA)->USER = addptype(((ttvsig_list*)chsig2->DATA)->USER, TTV_SIG_VCD_PREV_SIG, ttvsig);
 185                                     }
 186                                     if((ptslope = getptype(((ttvsig_list*)chsig2->DATA)->USER, TTV_SIG_VCD_SLOPE)) != NULL){
 187                                         *(float *)&ptslope->DATA=(float)(line->FMAX/TTV_UNIT);
 188                                     }else{
 189                                         ptslope = ((ttvsig_list*)chsig2->DATA)->USER = addptype(((ttvsig_list*)chsig2->DATA)->USER, TTV_SIG_VCD_SLOPE, NULL);
 190                                         *(float *)&ptslope->DATA=(float)(line->FMAX/TTV_UNIT);
 191                                     }
 192                                 }*/
 193                             }
 194                         }
 195                     }
 196                 }
 197             }
 198         }
 199       }
 200       test = vcd_goto_next_time ();
 201     }
 202     if((ptype = getptype(tf->USER, TTV_FIG_VCDPOWER)) != NULL) ptype->DATA = reverse((chain_list*)ptype->DATA);
 203     ttv_free_signals_from_netname(htsig);
 204     htsig = NULL;
 205     fclose(ptf);
 206 //    fprintf(stdout, "\nCONSO TOTALE: %g\n\n", consototale);
 207
 208 }
 209
 210 void DisplaySwitchingPower (void)
 211 {
 212     int i;
 213     char buf[512];
 214     int date;
 215     float nrj, total = 0.0;
 216
 217     Board *b;
 218     b=Board_CreateBoard();
 219     Board_SetSize(b, 0, 10, 'l');
 220     Board_SetSize(b, 1, 10, 'l');
 221     Board_NewLine(b);
 222     Board_SetValue(b, 0, "Time Date");
 223     Board_SetValue(b, 1, "Switching Power");
 224     Board_NewSeparation(b);
 225
 226     for (i = 1; i <= vcd_get_max_index(); i++){
 227         Board_NewLine(b);
 228         date = vcd_get_time_from_index(i);
 229         nrj = vcd_get_nrj_from_index(i);
 230         sprintf(buf,"%d", date);
 231         Board_SetValue(b, 0, buf);
 232         sprintf(buf,"%g", nrj);
 233         Board_SetValue(b, 1, buf);
 234         total += nrj;
 235     }
 236
 237     Board_NewSeparation(b);
 238     Board_NewLine(b);
 239     Board_SetValue(b, 0, "Total");
 240     sprintf(buf,"%g", total);
 241     Board_SetValue(b, 1, buf);
 242
 243     Board_Display(stdout, b, "");
 244     Board_FreeBoard(b);
 245
 246
 247 }
 248
 249 void DisplaySwitchingPowerSignal (TimingFigure *tf, char *signame)
 250 {
 251     ttvtrans_vcd_power *trans;
 252     ptype_list *ptype;
 253     char buf[512];
 254     int date;
 255     float nrj;
 256     ht *htsig=NULL;
 257     chain_list *chainsigs, *chsig;
 258     ttvsig_list *ttvsig;
 259
 260     Board *b;
 261     b=Board_CreateBoard();
 262     Board_SetSize(b, 0, 10, 'l');
 263     Board_SetSize(b, 1, 10, 'l');
 264     Board_NewSeparation(b);
 265     Board_NewLine(b);
 266     Board_SetValue(b, 0, signame);
 267     Board_SetValue(b, 1, "");
 268     Board_NewSeparation(b);
 269     Board_NewLine(b);
 270     Board_SetValue(b, 0, "Time Date");
 271     Board_SetValue(b, 1, "Switching Power");
 272     Board_NewSeparation(b);
 273
 274     chainsigs = ttv_get_signals_from_netname(tf, &htsig, namealloc(signame));
 275     for(chsig = chainsigs; chsig; chsig = chsig->NEXT){
 276         ttvsig = (ttvsig_list*)chsig->DATA;
 277         if((ptype = getptype(ttvsig->USER, TTV_SIG_VCDPOWER)) != NULL){
 278             for(trans = (ttvtrans_vcd_power*)ptype->DATA; trans; trans = trans->NEXT){
 279                 Board_NewLine(b);
 280                 date = trans->TIME;
 281                 nrj = trans->NRJ;
 282                 sprintf(buf,"%d", date);
 283                 Board_SetValue(b, 0, buf);
 284                 sprintf(buf,"%g", nrj);
 285                 Board_SetValue(b, 1, buf);
 286             }
 287         }
 288     }
 289     Board_NewSeparation(b);
 290     Board_Display(stdout, b, "");
 291     Board_FreeBoard(b);
 292
 293     ttv_free_signals_from_netname(htsig);
 294     htsig = NULL;
 295 }
 296
 297 float GetSwitchingPowerSignal_sub (TimingFigure *tf, char *signame, double interval_d, double begindate_d, double enddate_d, char *plot)
 298 {
 299     ttvtrans_vcd_power *trans;
 300     ptype_list *ptype;
 301     char buf[512];
 302     long date, prevdate = -1;
 303     double nrj, sumnrj, totalnrj;
 304     ht *htsig=NULL;
 305     chain_list *chainsigs, *chsig, *chain;
 306     ttvsig_list *ttvsig;
 307     FILE    *ptf=NULL ;
 308     long btime;
 309     long begindate;
 310     long interval;
 311     long enddate;
 312     float *nrjtab;
 313     long index = 0;
 314     long nbelem;
 315     long timemax = 0;
 316
 317     begindate = mbk_long_round(begindate_d/(vcd_get_ts()));
 318     if(interval_d > 0)
 319         interval = mbk_long_round(interval_d/(vcd_get_ts()));
 320     else
 321         interval = 1;
 322     enddate = mbk_long_round(enddate_d/(vcd_get_ts()));
 323
 324     btime = begindate + interval;
 325     Board *b;
 326     b=Board_CreateBoard();
 327     Board_SetSize(b, 0, 10, 'l');
 328     Board_SetSize(b, 1, 10, 'l');
 329
 330     if(!strcmp(signame, "*")){
 331         if((ptype = getptype(tf->USER, TTV_FIG_VCDPOWER)) != NULL){
 332             sumnrj = 0.0;
 333             totalnrj = 0.0;
 334             for(chain = (chain_list*)ptype->DATA; chain; chain = chain->NEXT){
 335                 trans = (ttvtrans_vcd_power*)chain->DATA;
 336                 date = trans->TIME;
 337                 if((interval == 1) && (date == prevdate)){
 338                     nrj += trans->NRJ;
 339                 }else{
 340                     nrj = trans->NRJ;
 341                 }
 342                 if(date <= begindate) continue;
 343                 if((btime - interval) < begindate || (enddate > 0 && (btime - interval) > enddate)){
 344                     btime += interval;
 345                     continue;
 346                 }
 347                 if(date <= btime){
 348                     sumnrj += nrj;
 349                 }else if(((interval == 1) || sumnrj != 0.0 || (sumnrj == 0.0 && interval != 1))
 350                       && (chain->NEXT && ((ttvtrans_vcd_power*)chain->NEXT->DATA)->TIME != date)){
 351                     Board_NewLine(b);
 352                     if(interval == 1){
 353                         sprintf(buf,"%ld", date);
 354                     }else{
 355                         sprintf(buf,"%ld", btime - interval/2);
 356                     }
 357                     Board_SetValue(b, 0, buf);
 358                     if(interval == 1){
 359                         sprintf(buf,"%g", nrj);
 360                     }else{
 361                         sprintf(buf,"%g", sumnrj / interval);
 362                     }
 363                     Board_SetValue(b, 1, buf);
 364                     if(interval == 1){
 365                         totalnrj += nrj;
 366                     }else{
 367                         totalnrj += sumnrj;
 368                         sumnrj = nrj;
 369                         btime += interval;
 370                     }
 371                 }
 372                 if(!chain->NEXT || (enddate > 0 && date > enddate)){
 373                     Board_NewLine(b);
 374                     if(interval == 1){
 375                         totalnrj += nrj;
 376                         sprintf(buf,"%ld", date);
 377                     }else{
 378                         sprintf(buf,"%ld", btime - interval/2);
 379                         totalnrj += sumnrj;
 380                     }
 381                     Board_SetValue(b, 0, buf);
 382                     if(interval == 1){
 383                         sprintf(buf,"%g", nrj);
 384                     }else{
 385                         sprintf(buf,"%g", sumnrj / interval);
 386                     }
 387                     Board_SetValue(b, 1, buf);
 388                     break;
 389                 }
 390                 prevdate = date;
 391             }
 392         }
 393     }else{
 394         chainsigs = ttv_get_signals_from_netname(tf, &htsig, namealloc(signame));
 395         for(chsig = chainsigs; chsig; chsig = chsig->NEXT){
 396             ttvsig = (ttvsig_list*)chsig->DATA;
 397             if((ptype = getptype(ttvsig->USER, TTV_SIG_VCDPOWER)) != NULL){
 398                 for(trans = (ttvtrans_vcd_power*)ptype->DATA; trans; trans = trans->NEXT){
 399                     if(trans->TIME > timemax)
 400                         timemax = trans->TIME;
 401                 }
 402             }
 403         }
 404         nbelem = (long)(timemax / interval) + 1;
 405         nrjtab = (float*)mbkalloc (nbelem * sizeof (float));
 406         memset(nrjtab, 0, nbelem * sizeof (float));
 407         for(chsig = chainsigs; chsig; chsig = chsig->NEXT){
 408             ttvsig = (ttvsig_list*)chsig->DATA;
 409             if((ptype = getptype(ttvsig->USER, TTV_SIG_VCDPOWER)) != NULL){
 410                 for(trans = (ttvtrans_vcd_power*)ptype->DATA; trans; trans = trans->NEXT){
 411                     date = trans->TIME;
 412                     nrj = trans->NRJ;
 413                     nrjtab[(long)(date / interval)] += nrj;
 414                 }
 415             }
 416         }
 417         totalnrj = 0.0;
 418         for(index = 0; index < nbelem; index++){
 419             if((index * interval) < begindate || (enddate > 0 && (index * interval) > enddate) || (nrjtab[index] == 0 && interval == 1)) continue;
 420             Board_NewLine(b);
 421             if(interval == 1){
 422                 sprintf(buf,"%ld", index);
 423             }else{
 424                 sprintf(buf,"%ld", index * interval + interval/2);
 425             }
 426             Board_SetValue(b, 0, buf);
 427             sprintf(buf,"%g", nrjtab[index] / interval);
 428             Board_SetValue(b, 1, buf);
 429             totalnrj += nrjtab[index];
 430         }
 431         mbkfree(nrjtab);
 432     }
 433     if(strcmp(plot, "NULL")){
 434 //        sprintf(buf,"%s_%ld", signame, interval);
 435         ptf = mbkfopen( plot, "plt", WRITE_TEXT );
 436         fprintf(ptf,"set origin 0,0\n") ;
 437         fprintf(ptf,"set xrange [0.0:*]\n") ;
 438         fprintf(ptf,"set yrange [0.0:*]\n") ;
 439         fprintf(ptf,"set xlabel \"TIME (PS)\"\n") ;
 440         if(interval == 1){
 441             fprintf(ptf,"set ylabel \"ENERGY (J)\"\n") ;
 442             fprintf(ptf,"plot '%s.dat' with impulses\n", plot) ;
 443         }else{
 444             fprintf(ptf,"set ylabel \"POWER (W)\"\n") ;
 445             fprintf(ptf,"plot '%s.dat' with boxes\n", plot) ;
 446         }
 447         fprintf(ptf,"pause -1 'Hit CR to finish'\n") ;
 448
 449         fclose(ptf) ;
 450         ptf = mbkfopen( plot, "dat", WRITE_TEXT );
 451         Board_Display(ptf, b, "");
 452         fclose(ptf) ;
 453     }
 454     Board_FreeBoard(b);
 455
 456     ttv_free_signals_from_netname(htsig);
 457     htsig = NULL;
 458
 459     return totalnrj / interval;
 460 }
 461