account for entry mask
[unix-history] / usr / src / usr.bin / gprof / arcs.c
index bd36218..dd3118d 100644 (file)
@@ -1,5 +1,5 @@
 #ifndef lint
 #ifndef lint
-    static     char *sccsid = "@(#)arcs.c      1.8 (Berkeley) %G%";
+    static     char *sccsid = "@(#)arcs.c      1.13 (Berkeley) %G%";
 #endif lint
 
 #include "gprof.h"
 #endif lint
 
 #include "gprof.h"
@@ -93,7 +93,7 @@ doarcs()
        parentp -> propself = 0.0;
        parentp -> propchild = 0.0;
        parentp -> printflag = FALSE;
        parentp -> propself = 0.0;
        parentp -> propchild = 0.0;
        parentp -> printflag = FALSE;
-       parentp -> toporder = 0;
+       parentp -> toporder = DFN_NAN;
        parentp -> cycleno = 0;
        parentp -> cyclehead = parentp;
        parentp -> cnext = 0;
        parentp -> cycleno = 0;
        parentp -> cyclehead = parentp;
        parentp -> cnext = 0;
@@ -103,10 +103,11 @@ doarcs()
     }
        /*
         *      topologically order things
     }
        /*
         *      topologically order things
-        *      from each of the roots of the call graph
+        *      if any node is unnumbered,
+        *          number it and any of its descendents.
         */
     for ( parentp = nl ; parentp < npe ; parentp++ ) {
         */
     for ( parentp = nl ; parentp < npe ; parentp++ ) {
-       if ( parentp -> parents == 0 ) {
+       if ( parentp -> toporder == DFN_NAN ) {
            dfn( parentp );
        }
     }
            dfn( parentp );
        }
     }
@@ -253,6 +254,7 @@ cyclelink()
     register nltype    *cyclenlp;
     int                        cycle;
     nltype             *memberp;
     register nltype    *cyclenlp;
     int                        cycle;
     nltype             *memberp;
+    arctype            *arcp;
 
        /*
         *      Count the number of cycles, and initialze the cycle lists
 
        /*
         *      Count the number of cycles, and initialze the cycle lists
@@ -282,12 +284,12 @@ cyclelink()
         */
     cycle = 0;
     for ( nlp = nl ; nlp < npe ; nlp++ ) {
         */
     cycle = 0;
     for ( nlp = nl ; nlp < npe ; nlp++ ) {
-       if ( nlp -> cyclehead != nlp || nlp -> cnext == 0 ) {
+       if ( !( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) ) {
            continue;
        }
        cycle += 1;
        cyclenlp = &cyclenl[cycle];
            continue;
        }
        cycle += 1;
        cyclenlp = &cyclenl[cycle];
-        cyclenlp -> name = "";         /* the name */
+        cyclenlp -> name = 0;          /* the name */
         cyclenlp -> value = 0;         /* the pc entry point */
         cyclenlp -> time = 0.0;                /* ticks in this routine */
         cyclenlp -> childtime = 0.0;   /* cumulative ticks in children */
         cyclenlp -> value = 0;         /* the pc entry point */
         cyclenlp -> time = 0.0;                /* ticks in this routine */
         cyclenlp -> childtime = 0.0;   /* cumulative ticks in children */
@@ -298,7 +300,7 @@ cyclelink()
        cyclenlp -> propchild = 0.0;    /* how much child time propagates */
        cyclenlp -> printflag = TRUE;   /* should this be printed? */
        cyclenlp -> index = 0;          /* index in the graph list */
        cyclenlp -> propchild = 0.0;    /* how much child time propagates */
        cyclenlp -> printflag = TRUE;   /* should this be printed? */
        cyclenlp -> index = 0;          /* index in the graph list */
-       cyclenlp -> toporder = 0;       /* graph call chain top-sort order */
+       cyclenlp -> toporder = DFN_NAN; /* graph call chain top-sort order */
        cyclenlp -> cycleno = cycle;    /* internal number of cycle on */
        cyclenlp -> cyclehead = cyclenlp;       /* pointer to head of cycle */
        cyclenlp -> cnext = nlp;        /* pointer to next member of cycle */
        cyclenlp -> cycleno = cycle;    /* internal number of cycle on */
        cyclenlp -> cyclehead = cyclenlp;       /* pointer to head of cycle */
        cyclenlp -> cnext = nlp;        /* pointer to next member of cycle */
@@ -311,10 +313,29 @@ cyclelink()
                printf( " is the head of cycle %d\n" , cycle );
            }
 #      endif DEBUG
                printf( " is the head of cycle %d\n" , cycle );
            }
 #      endif DEBUG
+           /*
+            *  link members to cycle header
+            */
        for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) { 
            memberp -> cycleno = cycle;
            memberp -> cyclehead = cyclenlp;
        }
        for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) { 
            memberp -> cycleno = cycle;
            memberp -> cyclehead = cyclenlp;
        }
+           /*
+            *  count calls from outside the cycle
+            *  and those among cycle members
+            */
+       for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) {
+           for ( arcp=memberp->parents ; arcp ; arcp=arcp->arc_parentlist ) {
+               if ( arcp -> arc_parentp == memberp ) {
+                   continue;
+               }
+               if ( arcp -> arc_parentp -> cycleno == cycle ) {
+                   cyclenlp -> selfcalls += arcp -> arc_count;
+               } else {
+                   cyclenlp -> ncall += arcp -> arc_count;
+               }
+           }
+       }
     }
 }
 
     }
 }
 
@@ -323,8 +344,6 @@ cycletime()
     int                        cycle;
     nltype             *cyclenlp;
     nltype             *childp;
     int                        cycle;
     nltype             *cyclenlp;
     nltype             *childp;
-    arctype            *arcp;
-    nltype             *parentp;
 
     for ( cycle = 1 ; cycle <= ncycle ; cycle += 1 ) {
        cyclenlp = &cyclenl[ cycle ];
 
     for ( cycle = 1 ; cycle <= ncycle ; cycle += 1 ) {
        cyclenlp = &cyclenl[ cycle ];
@@ -337,17 +356,6 @@ cycletime()
                continue;
            }
            cyclenlp -> time += childp -> time;
                continue;
            }
            cyclenlp -> time += childp -> time;
-           for ( arcp=childp->parents ; arcp ; arcp=arcp->arc_parentlist ) {
-               parentp = arcp -> arc_parentp;
-               if ( parentp == childp ) {
-                   continue;
-               }
-               if ( parentp -> cyclehead == cyclenlp ) {
-                   cyclenlp -> selfcalls += arcp -> arc_count;
-               } else {
-                   cyclenlp -> ncall += arcp -> arc_count;
-               }
-           }
        }
        cyclenlp -> propself = cyclenlp -> propfraction * cyclenlp -> time;
     }
        }
        cyclenlp -> propself = cyclenlp -> propfraction * cyclenlp -> time;
     }
@@ -440,8 +448,8 @@ doflags()
                printname( childp );
                printf( " ends up with printflag %d and propfraction %f\n" ,
                        childp -> printflag , childp -> propfraction );
                printname( childp );
                printf( " ends up with printflag %d and propfraction %f\n" ,
                        childp -> printflag , childp -> propfraction );
-               printf( "time %f propself %f\n" ,
-                       childp -> time , childp -> propself );
+               printf( "time %f propself %f printtime %f\n" ,
+                       childp -> time , childp -> propself , printtime );
            }
 #      endif DEBUG
     }
            }
 #      endif DEBUG
     }
@@ -471,10 +479,13 @@ inheritflags( childp )
        childp -> propfraction = 0.0;
        for (arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist) {
            parentp = arcp -> arc_parentp;
        childp -> propfraction = 0.0;
        for (arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist) {
            parentp = arcp -> arc_parentp;
+           if ( childp == parentp ) {
+               continue;
+           }
            childp -> printflag |= parentp -> printflag;
            childp -> propfraction += parentp -> propfraction
                                        * ( ( (double) arcp -> arc_count )
            childp -> printflag |= parentp -> printflag;
            childp -> propfraction += parentp -> propfraction
                                        * ( ( (double) arcp -> arc_count )
-                                         / ( (double) childp -> ncall) );
+                                         / ( (double) childp -> ncall ) );
        }
     } else {
            /*
        }
     } else {
            /*
@@ -490,8 +501,9 @@ inheritflags( childp )
                }
                parentp = arcp -> arc_parentp;
                headp -> printflag |= parentp -> printflag;
                }
                parentp = arcp -> arc_parentp;
                headp -> printflag |= parentp -> printflag;
-               headp -> propfraction += parentp -> propfraction *
-                                       (arcp -> arc_count / headp -> ncall);
+               headp -> propfraction += parentp -> propfraction
+                                       * ( ( (double) arcp -> arc_count )
+                                         / ( (double) headp -> ncall ) );
            }
        }
        for ( memp = headp ; memp ; memp = memp -> cnext ) {
            }
        }
        for ( memp = headp ; memp ; memp = memp -> cnext ) {