UNIX 6th Ed. - /usr/source/s2/prof.c

   1: /*
   2:  *  Print execution profile
   3:  */
   4: 
   5: struct nl {
   6:     char name[8];
   7:     int value;
   8:     float time;
   9:     int ncall[2];
  10: };
  11: 
  12: struct nl nl[600];
  13: 
  14: struct fnl {
  15:     char fname[8];
  16:     int flag;
  17:     int fvalue;
  18: };
  19: 
  20: struct cnt {
  21:     int cvalue;
  22:     int cncall[2];
  23: } cbuf[200];
  24: 
  25: struct inode {
  26:     int idev;
  27:     int inum;
  28:     int flags;
  29:     char nlink;
  30:     char uid;
  31:     char    gid;
  32:     char    size0;
  33:     int size;
  34:     int ptr[8];
  35:     int ctime[2];
  36:     int mtime[2];
  37:     int fill;
  38: };
  39: 
  40: int ibuf[259];
  41: int obuf[259];
  42: int buf[17];
  43: int i;
  44: int j;
  45: int highpc;
  46: int lowpc;
  47: int ccnt;
  48: int pcl;
  49: int pch;
  50: int bufs;
  51: int nname;
  52: double  time;
  53: double  totime;
  54: double  maxtime;
  55: double  scale;
  56: double  lastx;
  57: double  lasty;
  58: struct nl *np;
  59: struct nl *npe;
  60: int aflg;
  61: int vflg;
  62: int lflg;
  63: int symoff;
  64: int symsiz;
  65: int vf;
  66: int etext;
  67: int ncount;
  68: 
  69: main(argc, argv)
  70: char **argv;
  71: {
  72:     char *namfil;
  73:     int timcmp(), valcmp();
  74:     int nf, pf, overlap;
  75:     double fnc, ltod(), lastsx;
  76:     struct cnt *cp;
  77: 
  78:     obuf[0] = 1;
  79:     argv++;
  80:     namfil = "a.out";
  81:     while (argc>1) {
  82:         if (**argv == '-') {
  83:             if (*++*argv == 'l')
  84:                 lflg++;
  85:             if (**argv == 'a')
  86:                 aflg = 040;
  87:             if(**argv == 'v')
  88:                 vflg++;
  89:         } else
  90:             namfil = *argv;
  91:         argc--;
  92:         argv++;
  93:     }
  94:     if ((nf = open(namfil, 0)) < 0) {
  95:         printf("Can't find %s\n", namfil);
  96:         done();
  97:     }
  98:     read(nf, buf, 020);
  99:     if (buf[0] != 0407 && buf[0] != 0410 && buf[0] != 0411) { /* a.out magic */
 100:         printf("Bad format: %s\n", namfil);
 101:         done();
 102:     }
 103:     symsiz = buf[4];
 104:     symoff = buf[1] + buf[2];
 105:     if (buf[7] != 1)
 106:         symoff =<< 1;
 107:     seek(nf, symoff+020, 0);
 108:     if ((pf = open("mon.out", 0)) < 0) {
 109:         printf("No mon.out\n");
 110:         done();
 111:     }
 112:     fstat(pf, buf);
 113:     read(pf, &lowpc, 2);
 114:     read(pf, &highpc, 2);
 115:     read(pf, &ncount, 2);
 116:     bufs = buf->size/2 - 3*(ncount+1);
 117:     read(pf, cbuf, ncount*6);
 118:     lowpc = (lowpc>>1) & 077777;
 119:     highpc = (highpc>>1) & 077777;
 120:     npe = nl;
 121:     initf(nf);
 122:     for (nname = 0; symsiz > 0; symsiz =- 12) {
 123:         for(i=0; i<12; i++)
 124:             buf->fname[i] = getc(ibuf);
 125:         if ((buf->flag | aflg) != 042)
 126:             continue;
 127:         buf->fvalue = (buf->fvalue>>1) & 077777;
 128:         npe->value = buf->fvalue;
 129:         for (i=0; i<8; i++)
 130:             npe->name[i] = buf->fname[i];
 131:         npe++;
 132:         nname++;
 133:     }
 134:     if (nname == 0) {
 135:         printf("No symbols: %s\n", namfil);
 136:         done();
 137:     }
 138:     npe->value = 077777;
 139:     npe++;
 140:     for (cp = cbuf; cp < &cbuf[ncount]; cp++)
 141:         for (np = nl; np < npe; np++)
 142:             if (cp->cvalue-8 == np->value<<1) {
 143:                 np->ncall[0] = cp->cncall[0];
 144:                 np->ncall[1] = cp->cncall[1];
 145:                 break;
 146:             }
 147:     qsort(nl, nname, 18, &valcmp);
 148:     scale = (highpc-lowpc)/(bufs+0.0);
 149:     initf(pf);
 150:     for (i=0; (j = getc(ibuf)) != -1; i++) {
 151:         ccnt.fname[0] = j;
 152:         ccnt.fname[1] = getc(ibuf);
 153:         if (ccnt == 0)
 154:             continue;
 155:         time = ccnt;
 156:         if (ccnt<0)
 157:             time =+ 65536.;
 158:         totime =+ time;
 159:         if(time > maxtime)
 160:             maxtime = time;
 161:         pcl = lowpc + scale*i - 1;
 162:         pch = lowpc + scale*(i+1) - 1;
 163:         for (j=0; j<nname; j++) {
 164:             if (pch < nl[j].value)
 165:                 break;
 166:             if (pcl >= nl[j+1].value)
 167:                 continue;
 168:             overlap=(min(pch,nl[j+1].value)-max(pcl,nl[j].value));
 169:             nl[j].time =+ overlap*time/scale;
 170:         }
 171:     }
 172:     if (totime==0.0) {
 173:         printf("No time accumulated\n");
 174:         done();
 175:     }
 176:     if(!vflg)
 177:         goto print;
 178:     vf = open("/dev/vt0", 1);
 179:     if(vf < 0) {
 180:         printf("Cannot open vt\n");
 181:         done();
 182:     }
 183:     obuf[0] = vf;
 184:     vtch(1);
 185:     vtch(1);
 186:     vtch(3);
 187:     point(-2048., -2048.);
 188:     point(-2048., 2048.);
 189:     vtch(3);
 190:     point(0., -2048.);
 191:     point(0., 2048.);
 192:     for(j=0; j<9; j++) {
 193:         vtch(3);
 194:         point(-2048., 2048. - j*512.);
 195:         point(0., 2048. - j*512.);
 196:     }
 197:     lastx = 0.;
 198:     lasty = 2048.;
 199:     scale = 4096./(i+2);
 200:     seek(pf, 6*(ncount+1), 0);
 201:     initf(pf);
 202:     lastsx = 0.0;
 203:     while((j = getc(ibuf)) != -1) {
 204:         ccnt.fname[0] = j;
 205:         ccnt.fname[1] = getc(ibuf);
 206:         time = ccnt;
 207:         if(ccnt < 0)
 208:             time =+ 65536.;
 209:         vtch(3);
 210:         point(lastsx, lasty);
 211:         lastsx =- 2000.*time/totime;
 212:         point(lastsx, lasty-scale);
 213:         if (ccnt!=0 || lastx!=0.0) {
 214:             vtch(3);
 215:             point(lastx, lasty);
 216:             lastx = -time*2000./maxtime;
 217:             point(lastx, lasty);
 218:         }
 219:         lasty =- scale;
 220:     }
 221:     scale = 4096./(highpc-lowpc);
 222:     lastx = 50.;
 223:     for(np = nl; np<npe;  np++) {
 224:         if(np->value < lowpc)
 225:             continue;
 226:         if(np->value >= highpc)
 227:             continue;
 228:         time = np->time/totime;
 229:         lasty = 2048. - (np->value - lowpc)*scale;
 230:         vtch(3);
 231:         point(0., lasty);
 232:         point(50., lasty);
 233:         vtch(3);
 234:         point(lastx-50., lasty);
 235:         point(lastx, lasty);
 236:         vtch(9);
 237:         point(lastx+10., lasty+60.);
 238:         vtch(1);
 239:         vtch(3);
 240:         for(j=0; j<8; j++)
 241:             if(np->name[j] != '_')
 242:             vtch(np->name[j]);
 243:         vtch(0);
 244:         lastx =+ 500.;
 245:         if(lastx > 2000.)
 246:             lastx = 50.;
 247:     }
 248:     done();
 249: 
 250: print:
 251:     printf("    name %%time #call  ms/call\n");
 252:     if (!lflg)
 253:         qsort(nl, nname, 18, &timcmp);
 254:     for (np = nl; np<npe-1; np++) {
 255:         time = np->time/totime;
 256:         printf("%8.8s%6.1f", np->name, 100*time);
 257:         fnc = ltod(np->ncall);
 258:         if (fnc != 0.0) {
 259:             printf("%6s", locv(np->ncall[0], np->ncall[1]));
 260:             printf(" %7.2f\n", np->time/(fnc*.06));
 261:         } else
 262:             printf("\n");
 263:     }
 264:     done();
 265: }
 266: 
 267: min(a, b)
 268: {
 269:     if (a<b)
 270:         return(a);
 271:     return(b);
 272: }
 273: 
 274: max(a, b)
 275: {
 276:     if (a>b)
 277:         return(a);
 278:     return(b);
 279: }
 280: 
 281: valcmp(p1, p2)
 282: struct nl *p1, *p2;
 283: {
 284:     return(p1->value - p2->value);
 285: }
 286: 
 287: timcmp(p1, p2)
 288: struct nl *p1, *p2;
 289: {
 290:     float d;
 291: 
 292:     d = p2->time - p1->time;
 293:     if (d > 0.0)
 294:         return(1);
 295:     if (d < 0.0)
 296:         return(-1);
 297:     return(0);
 298: }
 299: 
 300: vtch(c)
 301: int c;
 302: {
 303: 
 304:     putchar(c&0377);
 305: }
 306: 
 307: point(x, y)
 308: float x, y;
 309: {
 310: 
 311:     point1(x);
 312:     point1(y);
 313: }
 314: 
 315: putchar(c)
 316: {
 317: 
 318:     putc(c, obuf);
 319: }
 320: 
 321: point1(xy)
 322: float xy;
 323: {
 324:     int ixy;
 325:     struct { char b1; char b2;};
 326: 
 327:     if(xy > 2047.)
 328:         xy = 2047.;
 329:     if(xy < -2048.)
 330:         xy = -2048.;
 331:     ixy = xy;
 332:     vtch(ixy.b1);
 333:     vtch(ixy.b2);
 334: }
 335: 
 336: done()
 337: {
 338: 
 339:     fflush(obuf);
 340:     exit();
 341: }
 342: 
 343: initf(f)
 344: {
 345: 
 346:     ibuf[0] = f;
 347:     ibuf[1] = 0;
 348:     ibuf[2] = 0;
 349:     ibuf[3] = 0;
 350: }

Defined functions

Defined variables

Defined struct's