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