These are the current versions (actually already 2 years old).

[unix-history] / 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 f16e42f..f68432b 100644 (file)
--- 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
 #ifndef lint

-    static     char *sccsid = "@(#)printgprof.c        1.9 (Berkeley) %G%";
-#endif lint
+static char sccsid[] = "@(#)printgprof.c       5.5 (Berkeley) %G%";
+#endif /* not lint */

 
 #include "gprof.h"
 
 
 #include "gprof.h"
 


@@ -8,12 +25,10 @@ printprof()
 {
     register nltype    *np;
     nltype             **sortednlp;
 {
     register nltype    *np;
     nltype             **sortednlp;

-    int                        index;
+    int                        index, timecmp();

 
 

-    printf( "\ngranularity: each sample hit covers %d byte(s)" ,
-           (long) scale * sizeof(UNIT) );
-    printf( " for %.2f%% of %.2f seconds\n\n" , 100.0/totime , totime / HZ );

     actime = 0.0;
     actime = 0.0;

+    printf( "\f\n" );

     flatprofheader();
        /*
         *      Sort the symbol table in by time
     flatprofheader();
        /*
         *      Sort the symbol table in by time


@@ -31,6 +46,7 @@ printprof()
        flatprofline( np );
     }
     actime = 0.0;
        flatprofline( np );
     }
     actime = 0.0;

+    cfree( sortednlp );

 }
 
 timecmp( npp1 , npp2 )
 }
 
 timecmp( npp1 , npp2 )


@@ -59,10 +75,25 @@ flatprofheader()
 {
     
     if ( bflag ) {
 {
     
     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 )
 }
 
 flatprofline( np )


@@ -73,33 +104,44 @@ flatprofline( np )
        return;
     }
     actime += np -> time;
        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 ) {
     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 {
     } else {

-       printf( " %7.7s" , "" );
+       printf( " %8.8s %8.8s %8.8s  " , "" , "" , "" );

     }
     }

-    printf( " %s\n" , np -> name );
+    printname( np );
+    printf( "\n" );

 }
 
 gprofheader()
 {
 
     if ( bflag ) {
 }
 
 gprofheader()
 {
 
     if ( bflag ) {

-       printblurb( "callg.blurb" );
+       printblurb( CALLG_BLURB );

     }
     printf( "\ngranularity: each sample hit covers %d byte(s)" ,
            (long) scale * sizeof(UNIT) );
     }
     printf( "\ngranularity: each sample hit covers %d byte(s)" ,
            (long) scale * sizeof(UNIT) );

-    printf( " for %.2f%% of %.2f seconds\n\n" ,
-           100.0/printtime , printtime / HZ );
+    if ( printtime > 0.0 ) {
+       printf( " for %.2f%% of %.2f seconds\n\n" ,
+               100.0/printtime , printtime / hz );
+    } else {
+       printf( " no time propagated\n\n" );
+           /*
+            *  this doesn't hurt, since all the numerators will be 0.0
+            */
+       printtime = 1.0;
+    }

     printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s     %-8.8s\n" ,
     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" ,
     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" );
 }
 
     printf( "\n" );
 }
 


@@ -111,9 +153,9 @@ gprofline( np )
     sprintf( kirkbuffer , "[%d]" , np -> index );
     printf( "%-6.6s %5.1f %7.2f %11.2f" ,
            kirkbuffer ,
     sprintf( kirkbuffer , "[%d]" , np -> index );
     printf( "%-6.6s %5.1f %7.2f %11.2f" ,
            kirkbuffer ,

-           100 * ( np -> time + np -> childtime ) / printtime ,
-           np -> time / HZ ,
-           np -> childtime / HZ );
+           100 * ( np -> propself + np -> propchild ) / printtime ,
+           np -> propself / hz ,
+           np -> propchild / hz );

     if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
        printf( " %7d" , np -> ncall );
        if ( np -> selfcalls != 0 ) {
     if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
        printf( " %7d" , np -> ncall );
        if ( np -> selfcalls != 0 ) {


@@ -128,43 +170,23 @@ gprofline( np )
     printf( "\n" );
 }
 
     printf( "\n" );
 }
 

-printgprof()
-{
+printgprof(timesortnlp)

     nltype     **timesortnlp;
     nltype     **timesortnlp;

+{

     int                index;
     nltype     *parentp;
 
        /*
     int                index;
     nltype     *parentp;
 
        /*

-        *      Now, sort by time + childtime.
-        *      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 ];
        if ( zflag == 0 &&
             parentp -> ncall == 0 &&
             parentp -> selfcalls == 0 &&
     gprofheader();
     for ( index = 0 ; index < nname + ncycle ; index ++ ) {
        parentp = timesortnlp[ index ];
        if ( zflag == 0 &&
             parentp -> ncall == 0 &&
             parentp -> selfcalls == 0 &&

-            parentp -> time == 0 &&
-            parentp -> childtime == 0 ) {
+            parentp -> propself == 0 &&
+            parentp -> propchild == 0 ) {

            continue;
        }
        if ( ! parentp -> printflag ) {
            continue;
        }
        if ( ! parentp -> printflag ) {


@@ -185,10 +207,11 @@ printgprof()
        printf( "-----------------------------------------------\n" );
        printf( "\n" );
     }
        printf( "-----------------------------------------------\n" );
        printf( "\n" );
     }

+    cfree( timesortnlp );

 }
 
     /*
 }
 
     /*

-     * sort by decreasing total time (time+childtime)
+     * sort by decreasing propagated time

      * if times are equal, but one is a cycle header,
      *         say that's first (e.g. less, i.e. -1).
      * if one's name doesn't have an underscore and the other does,
      * if times are equal, but one is a cycle header,
      *         say that's first (e.g. less, i.e. -1).
      * if one's name doesn't have an underscore and the other does,


@@ -204,8 +227,8 @@ totalcmp( npp1 , npp2 )
     register nltype    *np2 = *npp2;
     double             diff;
 
     register nltype    *np2 = *npp2;
     double             diff;
 

-    diff =    ( np1 -> time + np1 -> childtime )
-           - ( np2 -> time + np2 -> childtime );
+    diff =    ( np1 -> propself + np1 -> propchild )
+           - ( np2 -> propself + np2 -> propchild );

     if ( diff < 0.0 )
            return 1;
     if ( diff > 0.0 )
     if ( diff < 0.0 )
            return 1;
     if ( diff > 0.0 )


@@ -222,6 +245,10 @@ totalcmp( npp1 , npp2 )
        return -1;
     if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
        return 1;
        return -1;
     if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
        return 1;

+    if ( np1 -> ncall > np2 -> ncall )
+       return -1;
+    if ( np1 -> ncall < np2 -> ncall ) 
+       return 1;

     return strcmp( np1 -> name , np2 -> name );
 }
 
     return strcmp( np1 -> name , np2 -> name );
 }
 


@@ -261,7 +288,7 @@ printparents( childp )
                 */
            printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d     " ,
                    "" , "" ,
                 */
            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" );
                    arcp -> arc_count , cycleheadp -> ncall );
            printname( parentp );
            printf( "\n" );


@@ -294,7 +321,7 @@ printchildren( parentp )
                 */
            printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d     " ,
                    "" , "" ,
                 */
            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" );
                    arcp -> arc_count , childp -> cyclehead -> ncall );
            printname( childp );
            printf( "\n" );


@@ -312,10 +339,13 @@ printname( selfp )
            if ( debug & DFNDEBUG ) {
                printf( "{%d} " , selfp -> toporder );
            }
            if ( debug & DFNDEBUG ) {
                printf( "{%d} " , selfp -> toporder );
            }

+           if ( debug & PROPDEBUG ) {
+               printf( "%5.2f%% " , selfp -> propfraction );
+           }

 #      endif DEBUG
     }
     if ( selfp -> cycleno != 0 ) {
 #      endif DEBUG
     }
     if ( selfp -> cycleno != 0 ) {

-       printf( "\t<cycle %d>" , selfp -> cycleno );
+       printf( " <cycle %d>" , selfp -> cycleno );

     }
     if ( selfp -> index != 0 ) {
        if ( selfp -> printflag ) {
     }
     if ( selfp -> index != 0 ) {
        if ( selfp -> printflag ) {


@@ -343,9 +373,9 @@ sortchildren( parentp )
         *          *prevp      arc before the arc you are comparing.
         */
     sorted.arc_childlist = 0;
         *          *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 ;

-           arcp = detachedp , detachedp = detachedp -> arc_childlist ) {
+          (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {

            /*
             *  consider *arcp as disconnected
             *  insert it into sorted
            /*
             *  consider *arcp as disconnected
             *  insert it into sorted


@@ -383,9 +413,9 @@ sortparents( childp )
         *          *prevp      arc before the arc you are comparing.
         */
     sorted.arc_parentlist = 0;
         *          *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 ;

-           arcp = detachedp , detachedp = detachedp -> arc_parentlist ) {
+          (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {

            /*
             *  consider *arcp as disconnected
             *  insert it into sorted
            /*
             *  consider *arcp as disconnected
             *  insert it into sorted


@@ -417,9 +447,9 @@ printcycle( cyclep )
     sprintf( kirkbuffer , "[%d]" , cyclep -> index );
     printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
            kirkbuffer ,
     sprintf( kirkbuffer , "[%d]" , cyclep -> index );
     printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
            kirkbuffer ,

-           100 * ( cyclep -> time + cyclep -> childtime ) / printtime ,
-           cyclep -> time / HZ ,
-           cyclep -> childtime / HZ ,
+           100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
+           cyclep -> propself / hz ,
+           cyclep -> propchild / hz ,

            cyclep -> ncall );
     if ( cyclep -> selfcalls != 0 ) {
        printf( "+%-7d" , cyclep -> selfcalls );
            cyclep -> ncall );
     if ( cyclep -> selfcalls != 0 ) {
        printf( "+%-7d" , cyclep -> selfcalls );


@@ -441,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" , 
     sortmembers( cyclep );
     for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
        printf( "%6.6s %5.5s %7.2f %11.2f %7d" , 

-               "" , "" , memberp -> time / HZ , memberp -> childtime / HZ ,
+               "" , "" , memberp -> propself / hz , memberp -> propchild / hz ,

                memberp -> ncall );
        if ( memberp -> selfcalls != 0 ) {
            printf( "+%-7d" , memberp -> selfcalls );
                memberp -> ncall );
        if ( memberp -> selfcalls != 0 ) {
            printf( "+%-7d" , memberp -> selfcalls );


@@ -470,9 +500,9 @@ sortmembers( cyclep )
         */
     todo = cyclep -> cnext;
     cyclep -> cnext = 0;
         */
     todo = cyclep -> cnext;
     cyclep -> cnext = 0;

-    for (   doing = todo , todo = doing -> cnext ;
+    for (  (doing = todo)&&(todo = doing -> cnext);

            doing ;
            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;
        for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
            if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
                break;


@@ -484,7 +514,7 @@ sortmembers( cyclep )
 }
 
     /*
 }
 
     /*

-     * major sort is on time + childtime,
+     * major sort is on propself + propchild,

      * next is sort on ncalls + selfcalls.
      */
 int
      * next is sort on ncalls + selfcalls.
      */
 int


@@ -492,8 +522,8 @@ membercmp( this , that )
     nltype     *this;
     nltype     *that;
 {
     nltype     *this;
     nltype     *that;
 {

-    double     thistime = this -> time + this -> childtime;
-    double     thattime = that -> time + that -> childtime;
+    double     thistime = this -> propself + this -> propchild;
+    double     thattime = that -> propself + that -> propchild;

     long       thiscalls = this -> ncall + this -> selfcalls;
     long       thatcalls = that -> ncall + that -> selfcalls;
 
     long       thiscalls = this -> ncall + this -> selfcalls;
     long       thatcalls = that -> ncall + that -> selfcalls;
 


@@ -517,7 +547,7 @@ membercmp( this , that )
      * - if one arc is within a cycle, it's less than.
      * - if both arcs are within a cycle, compare arc counts.
      * - if neither arc is within a cycle, compare with
      * - if one arc is within a cycle, it's less than.
      * - if both arcs are within a cycle, compare arc counts.
      * - if neither arc is within a cycle, compare with

-     *         time + childtime as major key
+     *         arc_time + arc_childtime as major key

      *         arc count as minor key
      */
 int
      *         arc count as minor key
      */
 int


@@ -602,14 +632,12 @@ arccmp( thisp , thatp )
 printblurb( blurbname )
     char       *blurbname;
 {
 printblurb( blurbname )
     char       *blurbname;
 {

-    char       pathname[ BUFSIZ ];

     FILE       *blurbfile;
     int                input;
 
     FILE       *blurbfile;
     int                input;
 

-    sprintf( pathname , "%s%s" , BLURBLIB , blurbname );
-    blurbfile = fopen( pathname , "r" );
+    blurbfile = fopen( blurbname , "r" );

     if ( blurbfile == NULL ) {
     if ( blurbfile == NULL ) {

-       perror( pathname );
+       perror( blurbname );

        return;
     }
     while ( ( input = getc( blurbfile ) ) != EOF ) {
        return;
     }
     while ( ( input = getc( blurbfile ) ) != EOF ) {


@@ -617,3 +645,57 @@ printblurb( blurbname )
     }
     fclose( blurbfile );
 }
     }
     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 , "<cycle %d>" , nlp -> cycleno );
+               printf( "%-19.19s" , peterbuffer );
+           }
+       }
+       printf( "\n" );
+    }
+    cfree( namesortnlp );
+}