X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/54c5b05a2f0c61a3fbf5b887e9dba3899d6a2032..449f67e9bcd47ccd0964fb95b31b3e8635f74f01:/usr/src/usr.bin/gprof/printgprof.c diff --git a/usr/src/usr.bin/gprof/printgprof.c b/usr/src/usr.bin/gprof/printgprof.c index 54afb1fe3d..f68432b8a2 100644 --- a/usr/src/usr.bin/gprof/printgprof.c +++ b/usr/src/usr.bin/gprof/printgprof.c @@ -1,6 +1,23 @@ +/* + * Copyright (c) 1983 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + #ifndef lint - static char *sccsid = "@(#)printgprof.c 1.11 (Berkeley) %G%"; -#endif lint +static char sccsid[] = "@(#)printgprof.c 5.5 (Berkeley) %G%"; +#endif /* not lint */ #include "gprof.h" @@ -8,21 +25,10 @@ printprof() { register nltype *np; nltype **sortednlp; - int index; + int index, timecmp(); - printf( "\ngranularity: each sample hit covers %d byte(s)" , - (long) scale * sizeof(UNIT) ); - if ( totime > 0.0 ) { - printf( " for %.2f%% of %.2f seconds\n\n" , - 100.0/totime , totime / HZ ); - } else { - printf( " no time accumulated\n\n" ); - /* - * this doesn't hurt sinc eall the numerators will be zero. - */ - totime = 1.0; - } actime = 0.0; + printf( "\f\n" ); flatprofheader(); /* * Sort the symbol table in by time @@ -40,6 +46,7 @@ printprof() flatprofline( np ); } actime = 0.0; + cfree( sortednlp ); } timecmp( npp1 , npp2 ) @@ -68,10 +75,25 @@ flatprofheader() { if ( bflag ) { - printblurb( "flat.blurb" ); + printblurb( FLAT_BLURB ); } - printf( "%5.5s %7.7s %7.7s %7.7s %-8.8s\n" , - "%time" , "cumsecs" , "seconds" , "calls" , "name" ); + printf( "\ngranularity: each sample hit covers %d byte(s)" , + (long) scale * sizeof(UNIT) ); + if ( totime > 0.0 ) { + printf( " for %.2f%% of %.2f seconds\n\n" , + 100.0/totime , totime / hz ); + } else { + printf( " no time accumulated\n\n" ); + /* + * this doesn't hurt sinc eall the numerators will be zero. + */ + totime = 1.0; + } + printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , + "% " , "cumulative" , "self " , "" , "self " , "total " , "" ); + printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , + "time" , "seconds " , "seconds" , "calls" , + "ms/call" , "ms/call" , "name" ); } flatprofline( np ) @@ -82,27 +104,30 @@ flatprofline( np ) return; } actime += np -> time; - printf( "%5.1f %7.2f %7.2f" , - 100 * np -> time / totime , actime / HZ , np -> time / HZ ); + printf( "%5.1f %10.2f %8.2f" , + 100 * np -> time / totime , actime / hz , np -> time / hz ); if ( np -> ncall != 0 ) { - printf( " %7d" , np -> ncall ); + printf( " %8d %8.2f %8.2f " , np -> ncall , + 1000 * np -> time / hz / np -> ncall , + 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall ); } else { - printf( " %7.7s" , "" ); + printf( " %8.8s %8.8s %8.8s " , "" , "" , "" ); } - printf( " %s\n" , np -> name ); + printname( np ); + printf( "\n" ); } gprofheader() { if ( bflag ) { - printblurb( "callg.blurb" ); + printblurb( CALLG_BLURB ); } printf( "\ngranularity: each sample hit covers %d byte(s)" , (long) scale * sizeof(UNIT) ); if ( printtime > 0.0 ) { printf( " for %.2f%% of %.2f seconds\n\n" , - 100.0/printtime , printtime / HZ ); + 100.0/printtime , printtime / hz ); } else { printf( " no time propagated\n\n" ); /* @@ -111,12 +136,12 @@ gprofheader() printtime = 1.0; } printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , - "" , "" , "" , "" , "called" , "total" , "parents" , "" ); + "" , "" , "" , "" , "called" , "total" , "parents"); printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" , "index" , "%time" , "self" , "descendents" , "called" , "self" , "name" , "index" ); printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , - "" , "" , "" , "" , "called" , "total" , "children" , "" ); + "" , "" , "" , "" , "called" , "total" , "children"); printf( "\n" ); } @@ -129,8 +154,8 @@ gprofline( np ) printf( "%-6.6s %5.1f %7.2f %11.2f" , kirkbuffer , 100 * ( np -> propself + np -> propchild ) / printtime , - np -> propself / HZ , - np -> propchild / HZ ); + np -> propself / hz , + np -> propchild / hz ); if ( ( np -> ncall + np -> selfcalls ) != 0 ) { printf( " %7d" , np -> ncall ); if ( np -> selfcalls != 0 ) { @@ -145,35 +170,15 @@ gprofline( np ) printf( "\n" ); } -printgprof() -{ +printgprof(timesortnlp) nltype **timesortnlp; +{ int index; nltype *parentp; /* - * Now, sort by propself + propchild. - * sorting both the regular function names - * and cycle headers. - */ - timesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) ); - if ( timesortnlp == (nltype **) 0 ) { - fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami ); - } - for ( index = 0 ; index < nname ; index++ ) { - timesortnlp[index] = &nl[index]; - } - for ( index = 1 ; index <= ncycle ; index++ ) { - timesortnlp[nname+index-1] = &cyclenl[index]; - } - qsort( timesortnlp , nname + ncycle , sizeof(nltype *) , totalcmp ); - for ( index = 0 ; index < nname + ncycle ; index++ ) { - timesortnlp[ index ] -> index = index + 1; - } - /* - * Now, print out the structured profiling list + * Print out the structured profiling list */ - printf( "\f\n" ); gprofheader(); for ( index = 0 ; index < nname + ncycle ; index ++ ) { parentp = timesortnlp[ index ]; @@ -202,6 +207,7 @@ printgprof() printf( "-----------------------------------------------\n" ); printf( "\n" ); } + cfree( timesortnlp ); } /* @@ -282,7 +288,7 @@ printparents( childp ) */ printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " , "" , "" , - arcp -> arc_time / HZ , arcp -> arc_childtime / HZ , + arcp -> arc_time / hz , arcp -> arc_childtime / hz , arcp -> arc_count , cycleheadp -> ncall ); printname( parentp ); printf( "\n" ); @@ -315,7 +321,7 @@ printchildren( parentp ) */ printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " , "" , "" , - arcp -> arc_time / HZ , arcp -> arc_childtime / HZ , + arcp -> arc_time / hz , arcp -> arc_childtime / hz , arcp -> arc_count , childp -> cyclehead -> ncall ); printname( childp ); printf( "\n" ); @@ -339,7 +345,7 @@ printname( selfp ) # endif DEBUG } if ( selfp -> cycleno != 0 ) { - printf( "\t" , selfp -> cycleno ); + printf( " " , selfp -> cycleno ); } if ( selfp -> index != 0 ) { if ( selfp -> printflag ) { @@ -367,9 +373,9 @@ sortchildren( parentp ) * *prevp arc before the arc you are comparing. */ sorted.arc_childlist = 0; - for ( arcp = parentp -> children , detachedp = arcp -> arc_childlist ; + for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist); arcp ; - arcp = detachedp , detachedp = detachedp -> arc_childlist ) { + (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) { /* * consider *arcp as disconnected * insert it into sorted @@ -407,9 +413,9 @@ sortparents( childp ) * *prevp arc before the arc you are comparing. */ sorted.arc_parentlist = 0; - for ( arcp = childp -> parents , detachedp = arcp -> arc_parentlist ; + for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist); arcp ; - arcp = detachedp , detachedp = detachedp -> arc_parentlist ) { + (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) { /* * consider *arcp as disconnected * insert it into sorted @@ -442,8 +448,8 @@ printcycle( cyclep ) printf( "%-6.6s %5.1f %7.2f %11.2f %7d" , kirkbuffer , 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime , - cyclep -> propself / HZ , - cyclep -> propchild / HZ , + cyclep -> propself / hz , + cyclep -> propchild / hz , cyclep -> ncall ); if ( cyclep -> selfcalls != 0 ) { printf( "+%-7d" , cyclep -> selfcalls ); @@ -465,7 +471,7 @@ printmembers( cyclep ) sortmembers( cyclep ); for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) { printf( "%6.6s %5.5s %7.2f %11.2f %7d" , - "" , "" , memberp -> propself / HZ , memberp -> propchild / HZ , + "" , "" , memberp -> propself / hz , memberp -> propchild / hz , memberp -> ncall ); if ( memberp -> selfcalls != 0 ) { printf( "+%-7d" , memberp -> selfcalls ); @@ -494,9 +500,9 @@ sortmembers( cyclep ) */ todo = cyclep -> cnext; cyclep -> cnext = 0; - for ( doing = todo , todo = doing -> cnext ; + for ( (doing = todo)&&(todo = doing -> cnext); doing ; - doing = todo , todo = doing -> cnext ) { + (doing = todo )&&(todo = doing -> cnext )){ for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) { if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) { break; @@ -626,14 +632,12 @@ arccmp( thisp , thatp ) printblurb( blurbname ) char *blurbname; { - char pathname[ BUFSIZ ]; FILE *blurbfile; int input; - sprintf( pathname , "%s%s" , BLURBLIB , blurbname ); - blurbfile = fopen( pathname , "r" ); + blurbfile = fopen( blurbname , "r" ); if ( blurbfile == NULL ) { - perror( pathname ); + perror( blurbname ); return; } while ( ( input = getc( blurbfile ) ) != EOF ) { @@ -641,3 +645,57 @@ printblurb( blurbname ) } fclose( blurbfile ); } + +int +namecmp( npp1 , npp2 ) + nltype **npp1, **npp2; +{ + return( strcmp( (*npp1) -> name , (*npp2) -> name ) ); +} + +printindex() +{ + nltype **namesortnlp; + register nltype *nlp; + int index, nnames, todo, i, j; + char peterbuffer[ BUFSIZ ]; + + /* + * Now, sort regular function name alphbetically + * to create an index. + */ + namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) ); + if ( namesortnlp == (nltype **) 0 ) { + fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami ); + } + for ( index = 0 , nnames = 0 ; index < nname ; index++ ) { + if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 ) + continue; + namesortnlp[nnames++] = &nl[index]; + } + qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp ); + for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) { + namesortnlp[todo++] = &cyclenl[index]; + } + printf( "\f\nIndex by function name\n\n" ); + index = ( todo + 2 ) / 3; + for ( i = 0; i < index ; i++ ) { + for ( j = i; j < todo ; j += index ) { + nlp = namesortnlp[ j ]; + if ( nlp -> printflag ) { + sprintf( peterbuffer , "[%d]" , nlp -> index ); + } else { + sprintf( peterbuffer , "(%d)" , nlp -> index ); + } + if ( j < nnames ) { + printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name ); + } else { + printf( "%6.6s " , peterbuffer ); + sprintf( peterbuffer , "" , nlp -> cycleno ); + printf( "%-19.19s" , peterbuffer ); + } + } + printf( "\n" ); + } + cfree( namesortnlp ); +}