![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printgprof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / gprof|
Return to printgprof.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / gprof |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: static char sccsid[] = "@(#)printgprof.c 5.5 (Berkeley) 6/29/88";
20: #endif /* not lint */
21:
22: #include "gprof.h"
23:
24: printprof()
25: {
26: register nltype *np;
27: nltype **sortednlp;
28: int index, timecmp();
29:
30: actime = 0.0;
31: printf( "\f\n" );
32: flatprofheader();
33: /*
34: * Sort the symbol table in by time
35: */
36: sortednlp = (nltype **) calloc( nname , sizeof(nltype *) );
37: if ( sortednlp == (nltype **) 0 ) {
38: fprintf( stderr , "[printprof] ran out of memory for time sorting\n" );
39: }
40: for ( index = 0 ; index < nname ; index += 1 ) {
41: sortednlp[ index ] = &nl[ index ];
42: }
43: qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
44: for ( index = 0 ; index < nname ; index += 1 ) {
45: np = sortednlp[ index ];
46: flatprofline( np );
47: }
48: actime = 0.0;
49: cfree( sortednlp );
50: }
51:
52: timecmp( npp1 , npp2 )
53: nltype **npp1, **npp2;
54: {
55: double timediff;
56: long calldiff;
57:
58: timediff = (*npp2) -> time - (*npp1) -> time;
59: if ( timediff > 0.0 )
60: return 1 ;
61: if ( timediff < 0.0 )
62: return -1;
63: calldiff = (*npp2) -> ncall - (*npp1) -> ncall;
64: if ( calldiff > 0 )
65: return 1;
66: if ( calldiff < 0 )
67: return -1;
68: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
69: }
70:
71: /*
72: * header for flatprofline
73: */
74: flatprofheader()
75: {
76:
77: if ( bflag ) {
78: printblurb( FLAT_BLURB );
79: }
80: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
81: (long) scale * sizeof(UNIT) );
82: if ( totime > 0.0 ) {
83: printf( " for %.2f%% of %.2f seconds\n\n" ,
84: 100.0/totime , totime / hz );
85: } else {
86: printf( " no time accumulated\n\n" );
87: /*
88: * this doesn't hurt sinc eall the numerators will be zero.
89: */
90: totime = 1.0;
91: }
92: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
93: "% " , "cumulative" , "self " , "" , "self " , "total " , "" );
94: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
95: "time" , "seconds " , "seconds" , "calls" ,
96: "ms/call" , "ms/call" , "name" );
97: }
98:
99: flatprofline( np )
100: register nltype *np;
101: {
102:
103: if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
104: return;
105: }
106: actime += np -> time;
107: printf( "%5.1f %10.2f %8.2f" ,
108: 100 * np -> time / totime , actime / hz , np -> time / hz );
109: if ( np -> ncall != 0 ) {
110: printf( " %8d %8.2f %8.2f " , np -> ncall ,
111: 1000 * np -> time / hz / np -> ncall ,
112: 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
113: } else {
114: printf( " %8.8s %8.8s %8.8s " , "" , "" , "" );
115: }
116: printname( np );
117: printf( "\n" );
118: }
119:
120: gprofheader()
121: {
122:
123: if ( bflag ) {
124: printblurb( CALLG_BLURB );
125: }
126: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
127: (long) scale * sizeof(UNIT) );
128: if ( printtime > 0.0 ) {
129: printf( " for %.2f%% of %.2f seconds\n\n" ,
130: 100.0/printtime , printtime / hz );
131: } else {
132: printf( " no time propagated\n\n" );
133: /*
134: * this doesn't hurt, since all the numerators will be 0.0
135: */
136: printtime = 1.0;
137: }
138: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
139: "" , "" , "" , "" , "called" , "total" , "parents");
140: printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" ,
141: "index" , "%time" , "self" , "descendents" ,
142: "called" , "self" , "name" , "index" );
143: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
144: "" , "" , "" , "" , "called" , "total" , "children");
145: printf( "\n" );
146: }
147:
148: gprofline( np )
149: register nltype *np;
150: {
151: char kirkbuffer[ BUFSIZ ];
152:
153: sprintf( kirkbuffer , "[%d]" , np -> index );
154: printf( "%-6.6s %5.1f %7.2f %11.2f" ,
155: kirkbuffer ,
156: 100 * ( np -> propself + np -> propchild ) / printtime ,
157: np -> propself / hz ,
158: np -> propchild / hz );
159: if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
160: printf( " %7d" , np -> ncall );
161: if ( np -> selfcalls != 0 ) {
162: printf( "+%-7d " , np -> selfcalls );
163: } else {
164: printf( " %7.7s " , "" );
165: }
166: } else {
167: printf( " %7.7s %7.7s " , "" , "" );
168: }
169: printname( np );
170: printf( "\n" );
171: }
172:
173: printgprof(timesortnlp)
174: nltype **timesortnlp;
175: {
176: int index;
177: nltype *parentp;
178:
179: /*
180: * Print out the structured profiling list
181: */
182: gprofheader();
183: for ( index = 0 ; index < nname + ncycle ; index ++ ) {
184: parentp = timesortnlp[ index ];
185: if ( zflag == 0 &&
186: parentp -> ncall == 0 &&
187: parentp -> selfcalls == 0 &&
188: parentp -> propself == 0 &&
189: parentp -> propchild == 0 ) {
190: continue;
191: }
192: if ( ! parentp -> printflag ) {
193: continue;
194: }
195: if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
196: /*
197: * cycle header
198: */
199: printcycle( parentp );
200: printmembers( parentp );
201: } else {
202: printparents( parentp );
203: gprofline( parentp );
204: printchildren( parentp );
205: }
206: printf( "\n" );
207: printf( "-----------------------------------------------\n" );
208: printf( "\n" );
209: }
210: cfree( timesortnlp );
211: }
212:
213: /*
214: * sort by decreasing propagated time
215: * if times are equal, but one is a cycle header,
216: * say that's first (e.g. less, i.e. -1).
217: * if one's name doesn't have an underscore and the other does,
218: * say the one is first.
219: * all else being equal, sort by names.
220: */
221: int
222: totalcmp( npp1 , npp2 )
223: nltype **npp1;
224: nltype **npp2;
225: {
226: register nltype *np1 = *npp1;
227: register nltype *np2 = *npp2;
228: double diff;
229:
230: diff = ( np1 -> propself + np1 -> propchild )
231: - ( np2 -> propself + np2 -> propchild );
232: if ( diff < 0.0 )
233: return 1;
234: if ( diff > 0.0 )
235: return -1;
236: if ( np1 -> name == 0 && np1 -> cycleno != 0 )
237: return -1;
238: if ( np2 -> name == 0 && np2 -> cycleno != 0 )
239: return 1;
240: if ( np1 -> name == 0 )
241: return -1;
242: if ( np2 -> name == 0 )
243: return 1;
244: if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
245: return -1;
246: if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
247: return 1;
248: if ( np1 -> ncall > np2 -> ncall )
249: return -1;
250: if ( np1 -> ncall < np2 -> ncall )
251: return 1;
252: return strcmp( np1 -> name , np2 -> name );
253: }
254:
255: printparents( childp )
256: nltype *childp;
257: {
258: nltype *parentp;
259: arctype *arcp;
260: nltype *cycleheadp;
261:
262: if ( childp -> cyclehead != 0 ) {
263: cycleheadp = childp -> cyclehead;
264: } else {
265: cycleheadp = childp;
266: }
267: if ( childp -> parents == 0 ) {
268: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" ,
269: "" , "" , "" , "" , "" , "" );
270: return;
271: }
272: sortparents( childp );
273: for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
274: parentp = arcp -> arc_parentp;
275: if ( childp == parentp ||
276: ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
277: /*
278: * selfcall or call among siblings
279: */
280: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
281: "" , "" , "" , "" ,
282: arcp -> arc_count , "" );
283: printname( parentp );
284: printf( "\n" );
285: } else {
286: /*
287: * regular parent of child
288: */
289: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
290: "" , "" ,
291: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
292: arcp -> arc_count , cycleheadp -> ncall );
293: printname( parentp );
294: printf( "\n" );
295: }
296: }
297: }
298:
299: printchildren( parentp )
300: nltype *parentp;
301: {
302: nltype *childp;
303: arctype *arcp;
304:
305: sortchildren( parentp );
306: arcp = parentp -> children;
307: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
308: childp = arcp -> arc_childp;
309: if ( childp == parentp ||
310: ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
311: /*
312: * self call or call to sibling
313: */
314: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
315: "" , "" , "" , "" , arcp -> arc_count , "" );
316: printname( childp );
317: printf( "\n" );
318: } else {
319: /*
320: * regular child of parent
321: */
322: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
323: "" , "" ,
324: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
325: arcp -> arc_count , childp -> cyclehead -> ncall );
326: printname( childp );
327: printf( "\n" );
328: }
329: }
330: }
331:
332: printname( selfp )
333: nltype *selfp;
334: {
335:
336: if ( selfp -> name != 0 ) {
337: printf( "%s" , selfp -> name );
338: # ifdef DEBUG
339: if ( debug & DFNDEBUG ) {
340: printf( "{%d} " , selfp -> toporder );
341: }
342: if ( debug & PROPDEBUG ) {
343: printf( "%5.2f%% " , selfp -> propfraction );
344: }
345: # endif DEBUG
346: }
347: if ( selfp -> cycleno != 0 ) {
348: printf( " <cycle %d>" , selfp -> cycleno );
349: }
350: if ( selfp -> index != 0 ) {
351: if ( selfp -> printflag ) {
352: printf( " [%d]" , selfp -> index );
353: } else {
354: printf( " (%d)" , selfp -> index );
355: }
356: }
357: }
358:
359: sortchildren( parentp )
360: nltype *parentp;
361: {
362: arctype *arcp;
363: arctype *detachedp;
364: arctype sorted;
365: arctype *prevp;
366:
367: /*
368: * unlink children from parent,
369: * then insertion sort back on to sorted's children.
370: * *arcp the arc you have detached and are inserting.
371: * *detachedp the rest of the arcs to be sorted.
372: * sorted arc list onto which you insertion sort.
373: * *prevp arc before the arc you are comparing.
374: */
375: sorted.arc_childlist = 0;
376: for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist);
377: arcp ;
378: (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {
379: /*
380: * consider *arcp as disconnected
381: * insert it into sorted
382: */
383: for ( prevp = &sorted ;
384: prevp -> arc_childlist ;
385: prevp = prevp -> arc_childlist ) {
386: if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) {
387: break;
388: }
389: }
390: arcp -> arc_childlist = prevp -> arc_childlist;
391: prevp -> arc_childlist = arcp;
392: }
393: /*
394: * reattach sorted children to parent
395: */
396: parentp -> children = sorted.arc_childlist;
397: }
398:
399: sortparents( childp )
400: nltype *childp;
401: {
402: arctype *arcp;
403: arctype *detachedp;
404: arctype sorted;
405: arctype *prevp;
406:
407: /*
408: * unlink parents from child,
409: * then insertion sort back on to sorted's parents.
410: * *arcp the arc you have detached and are inserting.
411: * *detachedp the rest of the arcs to be sorted.
412: * sorted arc list onto which you insertion sort.
413: * *prevp arc before the arc you are comparing.
414: */
415: sorted.arc_parentlist = 0;
416: for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist);
417: arcp ;
418: (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {
419: /*
420: * consider *arcp as disconnected
421: * insert it into sorted
422: */
423: for ( prevp = &sorted ;
424: prevp -> arc_parentlist ;
425: prevp = prevp -> arc_parentlist ) {
426: if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) {
427: break;
428: }
429: }
430: arcp -> arc_parentlist = prevp -> arc_parentlist;
431: prevp -> arc_parentlist = arcp;
432: }
433: /*
434: * reattach sorted arcs to child
435: */
436: childp -> parents = sorted.arc_parentlist;
437: }
438:
439: /*
440: * print a cycle header
441: */
442: printcycle( cyclep )
443: nltype *cyclep;
444: {
445: char kirkbuffer[ BUFSIZ ];
446:
447: sprintf( kirkbuffer , "[%d]" , cyclep -> index );
448: printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
449: kirkbuffer ,
450: 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
451: cyclep -> propself / hz ,
452: cyclep -> propchild / hz ,
453: cyclep -> ncall );
454: if ( cyclep -> selfcalls != 0 ) {
455: printf( "+%-7d" , cyclep -> selfcalls );
456: } else {
457: printf( " %7.7s" , "" );
458: }
459: printf( " <cycle %d as a whole>\t[%d]\n" ,
460: cyclep -> cycleno , cyclep -> index );
461: }
462:
463: /*
464: * print the members of a cycle
465: */
466: printmembers( cyclep )
467: nltype *cyclep;
468: {
469: nltype *memberp;
470:
471: sortmembers( cyclep );
472: for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
473: printf( "%6.6s %5.5s %7.2f %11.2f %7d" ,
474: "" , "" , memberp -> propself / hz , memberp -> propchild / hz ,
475: memberp -> ncall );
476: if ( memberp -> selfcalls != 0 ) {
477: printf( "+%-7d" , memberp -> selfcalls );
478: } else {
479: printf( " %7.7s" , "" );
480: }
481: printf( " " );
482: printname( memberp );
483: printf( "\n" );
484: }
485: }
486:
487: /*
488: * sort members of a cycle
489: */
490: sortmembers( cyclep )
491: nltype *cyclep;
492: {
493: nltype *todo;
494: nltype *doing;
495: nltype *prev;
496:
497: /*
498: * detach cycle members from cyclehead,
499: * and insertion sort them back on.
500: */
501: todo = cyclep -> cnext;
502: cyclep -> cnext = 0;
503: for ( (doing = todo)&&(todo = doing -> cnext);
504: doing ;
505: (doing = todo )&&(todo = doing -> cnext )){
506: for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
507: if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
508: break;
509: }
510: }
511: doing -> cnext = prev -> cnext;
512: prev -> cnext = doing;
513: }
514: }
515:
516: /*
517: * major sort is on propself + propchild,
518: * next is sort on ncalls + selfcalls.
519: */
520: int
521: membercmp( this , that )
522: nltype *this;
523: nltype *that;
524: {
525: double thistime = this -> propself + this -> propchild;
526: double thattime = that -> propself + that -> propchild;
527: long thiscalls = this -> ncall + this -> selfcalls;
528: long thatcalls = that -> ncall + that -> selfcalls;
529:
530: if ( thistime > thattime ) {
531: return GREATERTHAN;
532: }
533: if ( thistime < thattime ) {
534: return LESSTHAN;
535: }
536: if ( thiscalls > thatcalls ) {
537: return GREATERTHAN;
538: }
539: if ( thiscalls < thatcalls ) {
540: return LESSTHAN;
541: }
542: return EQUALTO;
543: }
544: /*
545: * compare two arcs to/from the same child/parent.
546: * - if one arc is a self arc, it's least.
547: * - if one arc is within a cycle, it's less than.
548: * - if both arcs are within a cycle, compare arc counts.
549: * - if neither arc is within a cycle, compare with
550: * arc_time + arc_childtime as major key
551: * arc count as minor key
552: */
553: int
554: arccmp( thisp , thatp )
555: arctype *thisp;
556: arctype *thatp;
557: {
558: nltype *thisparentp = thisp -> arc_parentp;
559: nltype *thischildp = thisp -> arc_childp;
560: nltype *thatparentp = thatp -> arc_parentp;
561: nltype *thatchildp = thatp -> arc_childp;
562: double thistime;
563: double thattime;
564:
565: # ifdef DEBUG
566: if ( debug & TIMEDEBUG ) {
567: printf( "[arccmp] " );
568: printname( thisparentp );
569: printf( " calls " );
570: printname ( thischildp );
571: printf( " %f + %f %d/%d\n" ,
572: thisp -> arc_time , thisp -> arc_childtime ,
573: thisp -> arc_count , thischildp -> ncall );
574: printf( "[arccmp] " );
575: printname( thatparentp );
576: printf( " calls " );
577: printname( thatchildp );
578: printf( " %f + %f %d/%d\n" ,
579: thatp -> arc_time , thatp -> arc_childtime ,
580: thatp -> arc_count , thatchildp -> ncall );
581: printf( "\n" );
582: }
583: # endif DEBUG
584: if ( thisparentp == thischildp ) {
585: /* this is a self call */
586: return LESSTHAN;
587: }
588: if ( thatparentp == thatchildp ) {
589: /* that is a self call */
590: return GREATERTHAN;
591: }
592: if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
593: thisparentp -> cycleno == thischildp -> cycleno ) {
594: /* this is a call within a cycle */
595: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
596: thatparentp -> cycleno == thatchildp -> cycleno ) {
597: /* that is a call within the cycle, too */
598: if ( thisp -> arc_count < thatp -> arc_count ) {
599: return LESSTHAN;
600: }
601: if ( thisp -> arc_count > thatp -> arc_count ) {
602: return GREATERTHAN;
603: }
604: return EQUALTO;
605: } else {
606: /* that isn't a call within the cycle */
607: return LESSTHAN;
608: }
609: } else {
610: /* this isn't a call within a cycle */
611: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
612: thatparentp -> cycleno == thatchildp -> cycleno ) {
613: /* that is a call within a cycle */
614: return GREATERTHAN;
615: } else {
616: /* neither is a call within a cycle */
617: thistime = thisp -> arc_time + thisp -> arc_childtime;
618: thattime = thatp -> arc_time + thatp -> arc_childtime;
619: if ( thistime < thattime )
620: return LESSTHAN;
621: if ( thistime > thattime )
622: return GREATERTHAN;
623: if ( thisp -> arc_count < thatp -> arc_count )
624: return LESSTHAN;
625: if ( thisp -> arc_count > thatp -> arc_count )
626: return GREATERTHAN;
627: return EQUALTO;
628: }
629: }
630: }
631:
632: printblurb( blurbname )
633: char *blurbname;
634: {
635: FILE *blurbfile;
636: int input;
637:
638: blurbfile = fopen( blurbname , "r" );
639: if ( blurbfile == NULL ) {
640: perror( blurbname );
641: return;
642: }
643: while ( ( input = getc( blurbfile ) ) != EOF ) {
644: putchar( input );
645: }
646: fclose( blurbfile );
647: }
648:
649: int
650: namecmp( npp1 , npp2 )
651: nltype **npp1, **npp2;
652: {
653: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
654: }
655:
656: printindex()
657: {
658: nltype **namesortnlp;
659: register nltype *nlp;
660: int index, nnames, todo, i, j;
661: char peterbuffer[ BUFSIZ ];
662:
663: /*
664: * Now, sort regular function name alphbetically
665: * to create an index.
666: */
667: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
668: if ( namesortnlp == (nltype **) 0 ) {
669: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
670: }
671: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
672: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
673: continue;
674: namesortnlp[nnames++] = &nl[index];
675: }
676: qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp );
677: for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) {
678: namesortnlp[todo++] = &cyclenl[index];
679: }
680: printf( "\f\nIndex by function name\n\n" );
681: index = ( todo + 2 ) / 3;
682: for ( i = 0; i < index ; i++ ) {
683: for ( j = i; j < todo ; j += index ) {
684: nlp = namesortnlp[ j ];
685: if ( nlp -> printflag ) {
686: sprintf( peterbuffer , "[%d]" , nlp -> index );
687: } else {
688: sprintf( peterbuffer , "(%d)" , nlp -> index );
689: }
690: if ( j < nnames ) {
691: printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name );
692: } else {
693: printf( "%6.6s " , peterbuffer );
694: sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno );
695: printf( "%-19.19s" , peterbuffer );
696: }
697: }
698: printf( "\n" );
699: }
700: cfree( namesortnlp );
701: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.