8109a9af1f
things when sizeof(UNIT) becomes a runtime parameter. The relevant 2 is the one in profil(2)'s scaling of pc's to bucket numbers: bucket = (pc - offset) / 2 * profil_scale / 65536 gprof(1) must duplicate this scaling, bug for bug compatibly, so it must first do an integer division by 2 although this mainly makes scales larger than 65536 useless. sizeof(UNIT) was already wrong in gprof4, but there were no problems because the fake profil scale is a multiple of 2. There are also some rounding bugs in the scaling, but these are only problems if profil(2) is used directly to create unusual (and not useful) scales.
739 lines
20 KiB
C
739 lines
20 KiB
C
/*
|
|
* Copyright (c) 1983, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)printgprof.c 8.1 (Berkeley) 6/6/93";
|
|
#endif
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif /* not lint */
|
|
|
|
#include <err.h>
|
|
#include "gprof.h"
|
|
#include "pathnames.h"
|
|
|
|
printprof()
|
|
{
|
|
register nltype *np;
|
|
nltype **sortednlp;
|
|
int index, timecmp();
|
|
|
|
actime = 0.0;
|
|
printf( "\f\n" );
|
|
flatprofheader();
|
|
/*
|
|
* Sort the symbol table in by time
|
|
*/
|
|
sortednlp = (nltype **) calloc( nname , sizeof(nltype *) );
|
|
if ( sortednlp == (nltype **) 0 ) {
|
|
fprintf( stderr , "[printprof] ran out of memory for time sorting\n" );
|
|
}
|
|
for ( index = 0 ; index < nname ; index += 1 ) {
|
|
sortednlp[ index ] = &nl[ index ];
|
|
}
|
|
qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
|
|
for ( index = 0 ; index < nname ; index += 1 ) {
|
|
np = sortednlp[ index ];
|
|
flatprofline( np );
|
|
}
|
|
actime = 0.0;
|
|
free( sortednlp );
|
|
}
|
|
|
|
timecmp( npp1 , npp2 )
|
|
nltype **npp1, **npp2;
|
|
{
|
|
double timediff;
|
|
long calldiff;
|
|
|
|
timediff = (*npp2) -> time - (*npp1) -> time;
|
|
if ( timediff > 0.0 )
|
|
return 1 ;
|
|
if ( timediff < 0.0 )
|
|
return -1;
|
|
calldiff = (*npp2) -> ncall - (*npp1) -> ncall;
|
|
if ( calldiff > 0 )
|
|
return 1;
|
|
if ( calldiff < 0 )
|
|
return -1;
|
|
return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
|
|
}
|
|
|
|
/*
|
|
* header for flatprofline
|
|
*/
|
|
flatprofheader()
|
|
{
|
|
|
|
if ( bflag ) {
|
|
printblurb( _PATH_FLAT_BLURB );
|
|
}
|
|
printf( "\ngranularity: each sample hit covers %g byte(s)" ,
|
|
scale * HISTORICAL_SCALE_2 );
|
|
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" ,
|
|
hz >= 10000000 ? "ns/call" : hz >= 10000 ? "us/call" : "ms/call" ,
|
|
hz >= 10000000 ? "ns/call" : hz >= 10000 ? "us/call" : "ms/call" ,
|
|
"name" );
|
|
}
|
|
|
|
flatprofline( np )
|
|
register nltype *np;
|
|
{
|
|
|
|
if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
|
|
return;
|
|
}
|
|
actime += np -> time;
|
|
if (hz >= 10000)
|
|
printf( "%5.1f %10.3f %8.3f" ,
|
|
100 * np -> time / totime , actime / hz , np -> time / hz );
|
|
else
|
|
printf( "%5.1f %10.2f %8.2f" ,
|
|
100 * np -> time / totime , actime / hz , np -> time / hz );
|
|
if ( np -> ncall != 0 ) {
|
|
if (hz >= 10000000)
|
|
printf( " %8ld %8.0f %8.0f " , np -> ncall ,
|
|
1e9 * np -> time / hz / np -> ncall ,
|
|
1e9 * ( np -> time + np -> childtime ) / hz / np -> ncall );
|
|
else if (hz >= 10000)
|
|
printf( " %8ld %8.0f %8.0f " , np -> ncall ,
|
|
1e6 * np -> time / hz / np -> ncall ,
|
|
1e6 * ( np -> time + np -> childtime ) / hz / np -> ncall );
|
|
else
|
|
printf( " %8ld %8.2f %8.2f " , np -> ncall ,
|
|
1000 * np -> time / hz / np -> ncall ,
|
|
1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
|
|
} else {
|
|
printf( " %8.8s %8.8s %8.8s " , "" , "" , "" );
|
|
}
|
|
printname( np );
|
|
printf( "\n" );
|
|
}
|
|
|
|
gprofheader()
|
|
{
|
|
|
|
if ( bflag ) {
|
|
printblurb( _PATH_CALLG_BLURB );
|
|
}
|
|
printf( "\ngranularity: each sample hit covers %g byte(s)" ,
|
|
scale * HISTORICAL_SCALE_2 );
|
|
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" ,
|
|
"" , "" , "" , "" , "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");
|
|
printf( "\n" );
|
|
}
|
|
|
|
gprofline( np )
|
|
register nltype *np;
|
|
{
|
|
char kirkbuffer[ BUFSIZ ];
|
|
|
|
sprintf( kirkbuffer , "[%d]" , np -> index );
|
|
printf( "%-6.6s %5.1f %7.2f %11.2f" ,
|
|
kirkbuffer ,
|
|
100 * ( np -> propself + np -> propchild ) / printtime ,
|
|
np -> propself / hz ,
|
|
np -> propchild / hz );
|
|
if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
|
|
printf( " %7ld" , np -> npropcall );
|
|
if ( np -> selfcalls != 0 ) {
|
|
printf( "+%-7ld " , np -> selfcalls );
|
|
} else {
|
|
printf( " %7.7s " , "" );
|
|
}
|
|
} else {
|
|
printf( " %7.7s %7.7s " , "" , "" );
|
|
}
|
|
printname( np );
|
|
printf( "\n" );
|
|
}
|
|
|
|
printgprof(timesortnlp)
|
|
nltype **timesortnlp;
|
|
{
|
|
int index;
|
|
nltype *parentp;
|
|
|
|
/*
|
|
* Print out the structured profiling list
|
|
*/
|
|
gprofheader();
|
|
for ( index = 0 ; index < nname + ncycle ; index ++ ) {
|
|
parentp = timesortnlp[ index ];
|
|
if ( zflag == 0 &&
|
|
parentp -> ncall == 0 &&
|
|
parentp -> selfcalls == 0 &&
|
|
parentp -> propself == 0 &&
|
|
parentp -> propchild == 0 ) {
|
|
continue;
|
|
}
|
|
if ( ! parentp -> printflag ) {
|
|
continue;
|
|
}
|
|
if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
|
|
/*
|
|
* cycle header
|
|
*/
|
|
printcycle( parentp );
|
|
printmembers( parentp );
|
|
} else {
|
|
printparents( parentp );
|
|
gprofline( parentp );
|
|
printchildren( parentp );
|
|
}
|
|
printf( "\n" );
|
|
printf( "-----------------------------------------------\n" );
|
|
printf( "\n" );
|
|
}
|
|
free( timesortnlp );
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
* say the one is first.
|
|
* all else being equal, sort by names.
|
|
*/
|
|
int
|
|
totalcmp( npp1 , npp2 )
|
|
nltype **npp1;
|
|
nltype **npp2;
|
|
{
|
|
register nltype *np1 = *npp1;
|
|
register nltype *np2 = *npp2;
|
|
double diff;
|
|
|
|
diff = ( np1 -> propself + np1 -> propchild )
|
|
- ( np2 -> propself + np2 -> propchild );
|
|
if ( diff < 0.0 )
|
|
return 1;
|
|
if ( diff > 0.0 )
|
|
return -1;
|
|
if ( np1 -> name == 0 && np1 -> cycleno != 0 )
|
|
return -1;
|
|
if ( np2 -> name == 0 && np2 -> cycleno != 0 )
|
|
return 1;
|
|
if ( np1 -> name == 0 )
|
|
return -1;
|
|
if ( np2 -> name == 0 )
|
|
return 1;
|
|
if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
|
|
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 );
|
|
}
|
|
|
|
printparents( childp )
|
|
nltype *childp;
|
|
{
|
|
nltype *parentp;
|
|
arctype *arcp;
|
|
nltype *cycleheadp;
|
|
|
|
if ( childp -> cyclehead != 0 ) {
|
|
cycleheadp = childp -> cyclehead;
|
|
} else {
|
|
cycleheadp = childp;
|
|
}
|
|
if ( childp -> parents == 0 ) {
|
|
printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" ,
|
|
"" , "" , "" , "" , "" , "" );
|
|
return;
|
|
}
|
|
sortparents( childp );
|
|
for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
|
|
parentp = arcp -> arc_parentp;
|
|
if ( childp == parentp || ( arcp -> arc_flags & DEADARC ) ||
|
|
( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
|
|
/*
|
|
* selfcall or call among siblings
|
|
*/
|
|
printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s " ,
|
|
"" , "" , "" , "" ,
|
|
arcp -> arc_count , "" );
|
|
printname( parentp );
|
|
printf( "\n" );
|
|
} else {
|
|
/*
|
|
* regular parent of child
|
|
*/
|
|
printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld " ,
|
|
"" , "" ,
|
|
arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
|
|
arcp -> arc_count , cycleheadp -> npropcall );
|
|
printname( parentp );
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
printchildren( parentp )
|
|
nltype *parentp;
|
|
{
|
|
nltype *childp;
|
|
arctype *arcp;
|
|
|
|
sortchildren( parentp );
|
|
arcp = parentp -> children;
|
|
for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
|
|
childp = arcp -> arc_childp;
|
|
if ( childp == parentp || ( arcp -> arc_flags & DEADARC ) ||
|
|
( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
|
|
/*
|
|
* self call or call to sibling
|
|
*/
|
|
printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s " ,
|
|
"" , "" , "" , "" , arcp -> arc_count , "" );
|
|
printname( childp );
|
|
printf( "\n" );
|
|
} else {
|
|
/*
|
|
* regular child of parent
|
|
*/
|
|
printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld " ,
|
|
"" , "" ,
|
|
arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
|
|
arcp -> arc_count , childp -> cyclehead -> npropcall );
|
|
printname( childp );
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
printname( selfp )
|
|
nltype *selfp;
|
|
{
|
|
|
|
if ( selfp -> name != 0 ) {
|
|
printf( "%s" , selfp -> name );
|
|
# ifdef DEBUG
|
|
if ( debug & DFNDEBUG ) {
|
|
printf( "{%d} " , selfp -> toporder );
|
|
}
|
|
if ( debug & PROPDEBUG ) {
|
|
printf( "%5.2f%% " , selfp -> propfraction );
|
|
}
|
|
# endif DEBUG
|
|
}
|
|
if ( selfp -> cycleno != 0 ) {
|
|
printf( " <cycle %d>" , selfp -> cycleno );
|
|
}
|
|
if ( selfp -> index != 0 ) {
|
|
if ( selfp -> printflag ) {
|
|
printf( " [%d]" , selfp -> index );
|
|
} else {
|
|
printf( " (%d)" , selfp -> index );
|
|
}
|
|
}
|
|
}
|
|
|
|
sortchildren( parentp )
|
|
nltype *parentp;
|
|
{
|
|
arctype *arcp;
|
|
arctype *detachedp;
|
|
arctype sorted;
|
|
arctype *prevp;
|
|
|
|
/*
|
|
* unlink children from parent,
|
|
* then insertion sort back on to sorted's children.
|
|
* *arcp the arc you have detached and are inserting.
|
|
* *detachedp the rest of the arcs to be sorted.
|
|
* sorted arc list onto which you insertion sort.
|
|
* *prevp arc before the arc you are comparing.
|
|
*/
|
|
sorted.arc_childlist = 0;
|
|
for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist);
|
|
arcp ;
|
|
(arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {
|
|
/*
|
|
* consider *arcp as disconnected
|
|
* insert it into sorted
|
|
*/
|
|
for ( prevp = &sorted ;
|
|
prevp -> arc_childlist ;
|
|
prevp = prevp -> arc_childlist ) {
|
|
if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) {
|
|
break;
|
|
}
|
|
}
|
|
arcp -> arc_childlist = prevp -> arc_childlist;
|
|
prevp -> arc_childlist = arcp;
|
|
}
|
|
/*
|
|
* reattach sorted children to parent
|
|
*/
|
|
parentp -> children = sorted.arc_childlist;
|
|
}
|
|
|
|
sortparents( childp )
|
|
nltype *childp;
|
|
{
|
|
arctype *arcp;
|
|
arctype *detachedp;
|
|
arctype sorted;
|
|
arctype *prevp;
|
|
|
|
/*
|
|
* unlink parents from child,
|
|
* then insertion sort back on to sorted's parents.
|
|
* *arcp the arc you have detached and are inserting.
|
|
* *detachedp the rest of the arcs to be sorted.
|
|
* sorted arc list onto which you insertion sort.
|
|
* *prevp arc before the arc you are comparing.
|
|
*/
|
|
sorted.arc_parentlist = 0;
|
|
for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist);
|
|
arcp ;
|
|
(arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {
|
|
/*
|
|
* consider *arcp as disconnected
|
|
* insert it into sorted
|
|
*/
|
|
for ( prevp = &sorted ;
|
|
prevp -> arc_parentlist ;
|
|
prevp = prevp -> arc_parentlist ) {
|
|
if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) {
|
|
break;
|
|
}
|
|
}
|
|
arcp -> arc_parentlist = prevp -> arc_parentlist;
|
|
prevp -> arc_parentlist = arcp;
|
|
}
|
|
/*
|
|
* reattach sorted arcs to child
|
|
*/
|
|
childp -> parents = sorted.arc_parentlist;
|
|
}
|
|
|
|
/*
|
|
* print a cycle header
|
|
*/
|
|
printcycle( cyclep )
|
|
nltype *cyclep;
|
|
{
|
|
char kirkbuffer[ BUFSIZ ];
|
|
|
|
sprintf( kirkbuffer , "[%d]" , cyclep -> index );
|
|
printf( "%-6.6s %5.1f %7.2f %11.2f %7ld" ,
|
|
kirkbuffer ,
|
|
100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
|
|
cyclep -> propself / hz ,
|
|
cyclep -> propchild / hz ,
|
|
cyclep -> npropcall );
|
|
if ( cyclep -> selfcalls != 0 ) {
|
|
printf( "+%-7ld" , cyclep -> selfcalls );
|
|
} else {
|
|
printf( " %7.7s" , "" );
|
|
}
|
|
printf( " <cycle %d as a whole>\t[%d]\n" ,
|
|
cyclep -> cycleno , cyclep -> index );
|
|
}
|
|
|
|
/*
|
|
* print the members of a cycle
|
|
*/
|
|
printmembers( cyclep )
|
|
nltype *cyclep;
|
|
{
|
|
nltype *memberp;
|
|
|
|
sortmembers( cyclep );
|
|
for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
|
|
printf( "%6.6s %5.5s %7.2f %11.2f %7ld" ,
|
|
"" , "" , memberp -> propself / hz , memberp -> propchild / hz ,
|
|
memberp -> npropcall );
|
|
if ( memberp -> selfcalls != 0 ) {
|
|
printf( "+%-7ld" , memberp -> selfcalls );
|
|
} else {
|
|
printf( " %7.7s" , "" );
|
|
}
|
|
printf( " " );
|
|
printname( memberp );
|
|
printf( "\n" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* sort members of a cycle
|
|
*/
|
|
sortmembers( cyclep )
|
|
nltype *cyclep;
|
|
{
|
|
nltype *todo;
|
|
nltype *doing;
|
|
nltype *prev;
|
|
|
|
/*
|
|
* detach cycle members from cyclehead,
|
|
* and insertion sort them back on.
|
|
*/
|
|
todo = cyclep -> cnext;
|
|
cyclep -> cnext = 0;
|
|
for ( (doing = todo)&&(todo = doing -> cnext);
|
|
doing ;
|
|
(doing = todo )&&(todo = doing -> cnext )){
|
|
for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
|
|
if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
|
|
break;
|
|
}
|
|
}
|
|
doing -> cnext = prev -> cnext;
|
|
prev -> cnext = doing;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* major sort is on propself + propchild,
|
|
* next is sort on ncalls + selfcalls.
|
|
*/
|
|
int
|
|
membercmp( this , that )
|
|
nltype *this;
|
|
nltype *that;
|
|
{
|
|
double thistime = this -> propself + this -> propchild;
|
|
double thattime = that -> propself + that -> propchild;
|
|
long thiscalls = this -> ncall + this -> selfcalls;
|
|
long thatcalls = that -> ncall + that -> selfcalls;
|
|
|
|
if ( thistime > thattime ) {
|
|
return GREATERTHAN;
|
|
}
|
|
if ( thistime < thattime ) {
|
|
return LESSTHAN;
|
|
}
|
|
if ( thiscalls > thatcalls ) {
|
|
return GREATERTHAN;
|
|
}
|
|
if ( thiscalls < thatcalls ) {
|
|
return LESSTHAN;
|
|
}
|
|
return EQUALTO;
|
|
}
|
|
/*
|
|
* compare two arcs to/from the same child/parent.
|
|
* - if one arc is a self arc, it's least.
|
|
* - 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
|
|
* arc_time + arc_childtime as major key
|
|
* arc count as minor key
|
|
*/
|
|
int
|
|
arccmp( thisp , thatp )
|
|
arctype *thisp;
|
|
arctype *thatp;
|
|
{
|
|
nltype *thisparentp = thisp -> arc_parentp;
|
|
nltype *thischildp = thisp -> arc_childp;
|
|
nltype *thatparentp = thatp -> arc_parentp;
|
|
nltype *thatchildp = thatp -> arc_childp;
|
|
double thistime;
|
|
double thattime;
|
|
|
|
# ifdef DEBUG
|
|
if ( debug & TIMEDEBUG ) {
|
|
printf( "[arccmp] " );
|
|
printname( thisparentp );
|
|
printf( " calls " );
|
|
printname ( thischildp );
|
|
printf( " %f + %f %ld/%ld\n" ,
|
|
thisp -> arc_time , thisp -> arc_childtime ,
|
|
thisp -> arc_count , thischildp -> ncall );
|
|
printf( "[arccmp] " );
|
|
printname( thatparentp );
|
|
printf( " calls " );
|
|
printname( thatchildp );
|
|
printf( " %f + %f %ld/%ld\n" ,
|
|
thatp -> arc_time , thatp -> arc_childtime ,
|
|
thatp -> arc_count , thatchildp -> ncall );
|
|
printf( "\n" );
|
|
}
|
|
# endif DEBUG
|
|
if ( thisparentp == thischildp ) {
|
|
/* this is a self call */
|
|
return LESSTHAN;
|
|
}
|
|
if ( thatparentp == thatchildp ) {
|
|
/* that is a self call */
|
|
return GREATERTHAN;
|
|
}
|
|
if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
|
|
thisparentp -> cycleno == thischildp -> cycleno ) {
|
|
/* this is a call within a cycle */
|
|
if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
|
|
thatparentp -> cycleno == thatchildp -> cycleno ) {
|
|
/* that is a call within the cycle, too */
|
|
if ( thisp -> arc_count < thatp -> arc_count ) {
|
|
return LESSTHAN;
|
|
}
|
|
if ( thisp -> arc_count > thatp -> arc_count ) {
|
|
return GREATERTHAN;
|
|
}
|
|
return EQUALTO;
|
|
} else {
|
|
/* that isn't a call within the cycle */
|
|
return LESSTHAN;
|
|
}
|
|
} else {
|
|
/* this isn't a call within a cycle */
|
|
if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
|
|
thatparentp -> cycleno == thatchildp -> cycleno ) {
|
|
/* that is a call within a cycle */
|
|
return GREATERTHAN;
|
|
} else {
|
|
/* neither is a call within a cycle */
|
|
thistime = thisp -> arc_time + thisp -> arc_childtime;
|
|
thattime = thatp -> arc_time + thatp -> arc_childtime;
|
|
if ( thistime < thattime )
|
|
return LESSTHAN;
|
|
if ( thistime > thattime )
|
|
return GREATERTHAN;
|
|
if ( thisp -> arc_count < thatp -> arc_count )
|
|
return LESSTHAN;
|
|
if ( thisp -> arc_count > thatp -> arc_count )
|
|
return GREATERTHAN;
|
|
return EQUALTO;
|
|
}
|
|
}
|
|
}
|
|
|
|
printblurb( blurbname )
|
|
char *blurbname;
|
|
{
|
|
FILE *blurbfile;
|
|
int input;
|
|
|
|
blurbfile = fopen( blurbname , "r" );
|
|
if ( blurbfile == NULL ) {
|
|
perror( blurbname );
|
|
return;
|
|
}
|
|
while ( ( input = getc( blurbfile ) ) != EOF ) {
|
|
putchar( input );
|
|
}
|
|
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 ) {
|
|
warnx("ran out of memory for sorting");
|
|
}
|
|
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" );
|
|
}
|
|
free( namesortnlp );
|
|
}
|