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