![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / prof|
Return to prof.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / prof |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)prof.c 4.5 (Berkeley) 7/22/88";
3: #endif
4: /*
5: * prof
6: */
7: #include <stdio.h>
8: #include <sys/types.h>
9: #include <sys/stat.h>
10: #include <a.out.h>
11: #include <sys/time.h>
12:
13: typedef unsigned short UNIT; /* unit of profiling */
14: #define PCFUDGE 11
15: #define A_OUTNAME "a.out"
16: #define MON_OUTNAME "mon.out"
17: #define MON_SUMNAME "mon.sum"
18:
19: /*
20: * The symbol table;
21: * for each external in the specified file we gather
22: * its address, the number of calls and compute its share of cpu time.
23: */
24: struct nl {
25: char *name;
26: unsigned value;
27: float time;
28: long ncall;
29: } *nl;
30: int nname;
31: struct nl *np;
32: struct nl *npe;
33:
34: /*
35: * The header on the mon.out file.
36: * Mon.out consists of one of these headers, an array of ncount
37: * cnt structures (as below) and then an array of samples
38: * representing the discretized program counter values.
39: */
40: struct hdr {
41: UNIT *lowpc, *highpc;
42: int ncount;
43: } h;
44:
45: /*
46: * Each counter has an address and a number of calls.
47: */
48: struct cnt {
49: unsigned cvalue;
50: long cncall;
51: } *cbuf;
52:
53: /*
54: * Each discretized pc sample has
55: * a count of the number of samples in its range
56: */
57: UNIT *samples;
58:
59: FILE *pfile, *nfile;
60:
61: unsigned lowpc, highpc; /* range profiled */
62: double ransca, ranoff; /* scaling for blowing up plots */
63: unsigned sampbytes; /* number of bytes of samples */
64: int nsamples; /* number of samples */
65: double totime; /* total time for all routines */
66: double maxtime; /* maximum time of any routine (for plot) */
67: double scale; /* scale factor converting samples to pc
68: values: each sample covers scale bytes */
69: char *strtab; /* string table in core */
70: off_t ssiz; /* size of the string table */
71: struct exec xbuf; /* exec header of a.out */
72:
73: int aflg;
74: int nflg;
75: int vflg;
76: int lflg;
77: int zflg;
78: int sflag;
79:
80: char *namfil;
81:
82: int timcmp(), valcmp(), cntcmp();
83:
84: main(argc, argv)
85: char **argv;
86: {
87: int lowpct, highpct;
88:
89: /*
90: * Use highpct and lowpc as percentages, temporarily
91: * for graphing options involving blow-up
92: */
93: lowpct = -1;
94: highpct = -1;
95: argv++;
96: while ( *argv != 0 && **argv == '-' ) {
97: *argv += 1;
98: if (**argv == 'l')
99: lflg++;
100: else if (**argv == 'a')
101: aflg++;
102: else if (**argv == 'n')
103: nflg++;
104: else if (**argv == 'z')
105: zflg++;
106: else if (**argv == 'v')
107: vflg++;
108: else if ( **argv == 's' )
109: sflag++;
110: else if (**argv >= '0' && **argv <= '9') {
111: int i = atoi(*argv);
112: if (lowpct == -1)
113: lowpct = i;
114: else
115: highpct = i;
116: }
117: argv++;
118: }
119: if ( *argv != 0 ) {
120: namfil = *argv;
121: argv++;
122: } else {
123: namfil = A_OUTNAME;
124: }
125: if (lowpct >= 100)
126: lowpct = 0;
127: if (highpct <= lowpct || highpct > 100)
128: highpct = 100;
129: ransca = 100./(highpct-lowpct);
130: ranoff = 2040. + 40.8*lowpc*ransca;
131: /*
132: * get information about a.out file.
133: */
134: getnfile();
135: /*
136: * get information about mon.out file(s).
137: */
138: if ( *argv == 0 ) {
139: getpfile( MON_OUTNAME );
140: } else {
141: do {
142: getpfile( *argv );
143: argv++;
144: } while ( *argv != 0 );
145: }
146: asgnsamples(); /* assign samples to procedures */
147: #ifdef plot
148: if (vflg)
149: plotprof(); /* a plotted or ... */
150: else
151: #endif
152: printprof(); /* a printed profile */
153: if ( sflag != 0 ) {
154: putprof();
155: }
156: done();
157: }
158:
159: printprof()
160: {
161: double time, actime, hz;
162:
163: actime = 0;
164: hz = hertz();
165: printf(" %%time cumsecs #call ms/call name\n");
166: if (!lflg)
167: qsort(nl, nname, sizeof(struct nl), timcmp);
168: for (np = nl; np<npe-1; np++) {
169: if (zflg == 0 && np->time == 0 && np->ncall == 0)
170: continue;
171: time = np->time/totime;
172: actime += np->time;
173: printf("%6.1f%9.2f", 100*time, actime/hz);
174: if (np->ncall != 0)
175: printf("%7ld %8.2f",
176: np->ncall, (np->time*1000/hz)/np->ncall);
177: else
178: printf("%7.7s %8.8s", "", "");
179: printf(" %s\n", np->name);
180: }
181: }
182:
183: /*
184: * Set up string and symbol tables from a.out.
185: * On return symbol table is sorted by value.
186: */
187: getnfile()
188: {
189:
190: nfile = fopen(namfil,"r");
191: if (nfile == NULL) {
192: perror(namfil);
193: done();
194: }
195: fread(&xbuf, 1, sizeof(xbuf), nfile);
196: if (N_BADMAG(xbuf)) {
197: fprintf(stderr, "%s: bad format\n", namfil);
198: done();
199: }
200: getstrtab();
201: getsymtab();
202: qsort(nl, nname, sizeof(struct nl), valcmp);
203: }
204:
205: getstrtab()
206: {
207:
208: fseek(nfile, N_SYMOFF(xbuf) + xbuf.a_syms, 0);
209: if (fread(&ssiz, sizeof (ssiz), 1, nfile) == 0) {
210: fprintf(stderr, "%s: no string table (old format?)\n", namfil);
211: done();
212: }
213: strtab = (char *)calloc(ssiz, 1);
214: if (strtab == NULL) {
215: fprintf(stderr, "%s: no room for %d bytes of string table",
216: namfil, ssiz);
217: done();
218: }
219: if (fread(strtab+sizeof(ssiz), ssiz-sizeof(ssiz), 1, nfile) != 1) {
220: fprintf(stderr, "%s: error reading string table\n", namfil);
221: done();
222: }
223: }
224:
225: /*
226: * Read in symbol table
227: */
228: getsymtab()
229: {
230: register int i;
231:
232: /* pass1 - count symbols */
233: fseek(nfile, N_SYMOFF(xbuf), 0);
234: nname = 0;
235: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
236: struct nlist nbuf;
237: fread(&nbuf, sizeof(nbuf), 1, nfile);
238: if (nbuf.n_type!=N_TEXT && nbuf.n_type!=N_TEXT+N_EXT)
239: continue;
240: if (aflg==0 && nbuf.n_type!=N_TEXT+N_EXT)
241: continue;
242: nname++;
243: }
244: if (nname == 0) {
245: fprintf(stderr, "%s: no symbols\n", namfil);
246: done();
247: }
248: nl = (struct nl *)calloc((nname+1), sizeof (struct nl));
249: if (nl == 0) {
250: fprintf(stderr, "prof: No room for %d bytes of symbol table\n",
251: (nname+1) * sizeof (struct nlist));
252: done();
253: }
254:
255: /* pass2 - read symbols */
256: fseek(nfile, N_SYMOFF(xbuf), 0);
257: npe = nl;
258: nname = 0;
259: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
260: struct nlist nbuf;
261: fread(&nbuf, sizeof(nbuf), 1, nfile);
262: if (nbuf.n_type!=N_TEXT && nbuf.n_type!=N_TEXT+N_EXT)
263: continue;
264: if (aflg==0 && nbuf.n_type!=N_TEXT+N_EXT)
265: continue;
266: npe->value = nbuf.n_value/sizeof(UNIT);
267: npe->name = strtab+nbuf.n_un.n_strx;
268: npe++;
269: nname++;
270: }
271: npe->value = -1;
272: npe++;
273: }
274:
275: /*
276: * information from a mon.out file is in two parts:
277: * the counters of how many times each procedure was called,
278: * if it was called at all;
279: * and an array of sampling hits within pc ranges.
280: * the counters must be dealt with on a file-by-file basis,
281: * since which procedures are represented may vary.
282: * the samples ranges are fixed, but must be summed across
283: * files, and then distributed among procedures, because
284: * of the wierd way the plotting is done.
285: */
286: getpfile(filename)
287: char *filename;
288: {
289:
290: openpfile(filename);
291: readcntrs();
292: asgncntrs(); /* assign counts to procedures */
293: readsamples();
294: closepfile();
295: }
296:
297: openpfile(filename)
298: char *filename;
299: {
300: struct stat stb;
301:
302: if((pfile = fopen(filename, "r")) == NULL) {
303: perror(filename);
304: done();
305: }
306: fstat(fileno(pfile), &stb);
307: fread(&h, sizeof(struct hdr), 1, pfile);
308: lowpc = h.lowpc - (UNIT *)0;
309: highpc = h.highpc - (UNIT *)0;
310: sampbytes =
311: stb.st_size - sizeof(struct hdr) - h.ncount*sizeof(struct cnt);
312: nsamples = sampbytes / sizeof (UNIT);
313: }
314:
315: closepfile()
316: {
317:
318: fclose(pfile);
319: free(cbuf);
320: }
321:
322: readcntrs()
323: {
324: struct cnt *kp;
325:
326: cbuf = (struct cnt *)calloc((h.ncount+1), sizeof (struct cnt));
327: if (cbuf == 0) {
328: fprintf(stderr, "prof: No room for %d bytes of count buffer\n",
329: (h.ncount+1) * sizeof (struct cnt));
330: exit(1);
331: }
332: fread(cbuf, sizeof(struct cnt), h.ncount, pfile);
333: /* eliminate zero counters and scale counter pc values */
334: if (h.ncount) {
335: kp = &cbuf[h.ncount - 1];
336: for (;;) {
337: if (kp->cvalue==0) {
338: h.ncount=kp-cbuf;
339: ++kp;
340: break;
341: }
342: if (kp == cbuf) {
343: h.ncount = 0;
344: break;
345: }
346: --kp;
347: }
348: for (; --kp>=cbuf; )
349: kp->cvalue /= sizeof(UNIT);
350: }
351: /* sort counters */
352: qsort(cbuf, h.ncount, sizeof(struct cnt), cntcmp);
353: }
354:
355: /*
356: * Assign counters to the procedures to which they belong
357: */
358: asgncntrs()
359: {
360: register int i;
361: struct cnt *kp;
362:
363: kp = &cbuf[h.ncount-1];
364: np = npe;
365: while (--np>=nl) {
366: if (kp<cbuf || np->value > kp->cvalue)
367: continue;
368: /* skip ``static'' functions */
369: while (kp >= cbuf && kp->cvalue > np->value + PCFUDGE)
370: --kp;
371: if (kp->cvalue >= np->value) {
372: np->ncall += kp->cncall;
373: --kp;
374: }
375: }
376: }
377:
378: readsamples()
379: {
380: register i;
381: UNIT sample;
382: int totalt;
383:
384: if (samples == 0) {
385: samples = (UNIT *)
386: calloc(sampbytes, sizeof (UNIT));
387: if (samples == 0) {
388: printf("prof: No room for %d sample pc's\n",
389: sampbytes / sizeof (UNIT));
390: done();
391: }
392: }
393: for (i = 0; ; i++) {
394: fread(&sample, sizeof (UNIT), 1, pfile);
395: if (feof(pfile))
396: break;
397: samples[i] += sample;
398: totalt += sample;
399: }
400: if (i != nsamples) {
401: fprintf(stderr,
402: "prof: unexpected EOF after reading %d/%d samples\n",
403: --i, nsamples);
404: done();
405: }
406: }
407:
408: /*
409: * Assign samples to the procedures to which they belong.
410: */
411: asgnsamples()
412: {
413: register j;
414: UNIT ccnt;
415: double time;
416: unsigned pcl, pch;
417: register int i;
418: int overlap;
419:
420: /* read samples and assign to namelist symbols */
421: scale = highpc - lowpc;
422: scale /= nsamples;
423: for (i=0; i < nsamples; i++) {
424: ccnt = samples[i];
425: if (ccnt == 0)
426: continue;
427: pcl = lowpc + scale*i;
428: pch = lowpc + scale*(i+1);
429: time = ccnt;
430: totime += time;
431: if(time > maxtime)
432: maxtime = time;
433: for (j=0; j<nname; j++) {
434: if (pch < nl[j].value)
435: break;
436: if (pcl >= nl[j+1].value)
437: continue;
438: overlap=(min(pch,nl[j+1].value)-max(pcl,nl[j].value));
439: if (overlap>0)
440: nl[j].time += overlap*time/scale;
441: }
442: }
443: if (totime==0.0) {
444: fprintf(stderr, "No time accumulated\n");
445: /*
446: done();
447: */
448: totime=1.0;
449: }
450: }
451:
452: /*
453: * dump what you have out to a mon.out style file.
454: */
455: putprof()
456: {
457: FILE *sfile;
458: struct nl *np;
459: struct cnt kp;
460: int i;
461:
462: sfile = fopen(MON_SUMNAME, "w");
463: if (sfile == NULL) {
464: perror(MON_SUMNAME);
465: done();
466: }
467: /*
468: * build a new header.
469: * h.lowpc and h.highpc are already fine.
470: * fix h.ncount to count non-zero calls,
471: * and the one zero call which marks the end.
472: */
473: h.ncount = 0;
474: for (np = nl; np < npe-1 ; np++)
475: if (np->ncall > 0)
476: h.ncount++;
477: h.ncount++;
478: fwrite(&h, sizeof (struct hdr), 1, sfile);
479: for (np = nl; np < npe-1; np++) {
480: if (np->ncall > 0) {
481: kp.cvalue = np->value * sizeof (UNIT);
482: kp.cncall = np->ncall;
483: fwrite(&kp, sizeof (struct cnt), 1, sfile);
484: }
485: }
486: kp.cvalue = 0;
487: kp.cncall = 0;
488: fwrite(&kp, sizeof (struct cnt), 1, sfile);
489: fwrite(samples, sizeof (UNIT), nsamples, sfile);
490: fclose(sfile);
491: }
492:
493: /*
494: * discover the tick frequency of the machine
495: * if something goes wrong, we return 1.
496: */
497: hertz()
498: {
499: struct itimerval tim;
500:
501: tim.it_interval.tv_sec = 0;
502: tim.it_interval.tv_usec = 1;
503: tim.it_value.tv_sec = 0;
504: tim.it_value.tv_usec = 0;
505: setitimer(ITIMER_REAL, &tim, 0);
506: setitimer(ITIMER_REAL, 0, &tim);
507: if (tim.it_interval.tv_usec < 1)
508: return (1);
509: return (1000000 / tim.it_interval.tv_usec);
510: }
511:
512: min(a, b)
513: {
514: if (a<b)
515: return(a);
516: return(b);
517: }
518:
519: max(a, b)
520: {
521: if (a>b)
522: return(a);
523: return(b);
524: }
525:
526: valcmp(p1, p2)
527: struct nl *p1, *p2;
528: {
529:
530: return(p1->value - p2->value);
531: }
532:
533: timcmp(p1, p2)
534: struct nl *p1, *p2;
535: {
536: float d;
537:
538: if (nflg && p2->ncall != p1->ncall)
539: return (p2->ncall - p1->ncall);
540: d = p2->time - p1->time;
541: if (d > 0.0)
542: return(1);
543: if (d < 0.0)
544: return(-1);
545: return(strcmp(p1->name,p2->name));
546: }
547:
548: cntcmp(p1, p2)
549: struct cnt *p1, *p2;
550: {
551:
552: return(p1->cvalue - p2->cvalue);
553: }
554:
555: done()
556: {
557:
558: #ifdef plot
559: if(vflg) {
560: point(0, -2040);
561: closepl();
562: }
563: #endif
564: exit(0);
565: }
566:
567: #ifdef plot
568: plotprof()
569: {
570: double time, lastx, lasty, lastsx;
571: register i;
572:
573: openpl();
574: erase();
575: space(-2048, -2048, 2048, 2048);
576: line(-2040, -2040, -2040, 2040);
577: line(0, 2040, 0, -2040);
578: for(i=0; i<11; i++)
579: line(-2040, 2040-i*408, 0, 2040-i*408);
580: lastx = 0.;
581: lasty = ranoff;
582: scale = (4080.*ransca)/(sampbytes/sizeof(UNIT));
583: lastsx = 0.0;
584: for(i = 0; i < nsamples; i++) {
585: UNIT ccnt;
586: double tx, ty;
587: ccnt = samples[i];
588: time = ccnt;
589: tx = lastsx;
590: ty = lasty;
591: lastsx -= 2000.*time/totime;
592: lasty -= scale;
593: if(lasty >= -2040. && ty <= 2040.) {
594: line((int)tx, (int)ty, (int)lastsx, (int)lasty);
595: if (ccnt!=0 || lastx!=0.0) {
596: tx = lastx;
597: lastx = -time*2000./maxtime;
598: ty += scale/2;
599: line(0, (int)ty, (int)tx, (int)ty);
600: }
601: }
602: }
603: scale = (4080.*ransca)/(highpc-lowpc);
604: lastx = 50.;
605: for(np = nl; np<npe; np++) {
606: if(np->value < lowpc)
607: continue;
608: if(np->value >= highpc)
609: continue;
610: if(zflg == 0 && np->time == 0 && np->ncall == 0)
611: continue;
612: time = np->time/totime;
613: lasty = ranoff - (np->value - lowpc)*scale;
614: if(lasty >= -2040. && lasty <= 2040.) {
615: char bufl[BUFSIZ], *namp;
616: register j;
617: line(0, (int)lasty, 50, (int)lasty);
618: line((int)(lastx-50),(int)lasty,(int)lastx,(int)lasty);
619: move((int)(lastx+30), (int)(lasty+10));
620: sprintf(bufl, "%s", np->name + (np->name[0] == '_'));
621: label(bufl);
622: }
623: lastx += 500.;
624: if(lastx > 2000.)
625: lastx = 50.;
626: }
627: }
628: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.