Return to gprof.h CVS log

Up to [CSRG BSD Unix] / 42BSD / sys / h

Annotation of 42BSD/sys/h/gprof.h, revision 1.1

1.1     ! root        1: /*     gprof.h 6.1     83/07/29        */
        !             2: 
        !             3: struct phdr {
        !             4:     char       *lpc;
        !             5:     char       *hpc;
        !             6:     int                ncnt;
        !             7: };
        !             8: 
        !             9:     /*
        !            10:      * histogram counters are unsigned shorts (according to the kernel).
        !            11:      */
        !            12: #define        HISTCOUNTER     unsigned short
        !            13: 
        !            14:     /*
        !            15:      * fraction of text space to allocate for histogram counters
        !            16:      * here, 1/2
        !            17:      */
        !            18: #define        HISTFRACTION    2
        !            19: 
        !            20:     /*
        !            21:      * Fraction of text space to allocate for from hash buckets.
        !            22:      * The value of HASHFRACTION is based on the minimum number of bytes
        !            23:      * of separation between two subroutine call points in the object code.
        !            24:      * Given MIN_SUBR_SEPARATION bytes of separation the value of
        !            25:      * HASHFRACTION is calculated as:
        !            26:      *
        !            27:      *         HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
        !            28:      *
        !            29:      * For the VAX, the shortest two call sequence is:
        !            30:      *
        !            31:      *         calls   $0,(r0)
        !            32:      *         calls   $0,(r0)
        !            33:      *
        !            34:      * which is separated by only three bytes, thus HASHFRACTION is 
        !            35:      * calculated as:
        !            36:      *
        !            37:      *         HASHFRACTION = 3 / (2 * 2 - 1) = 1
        !            38:      *
        !            39:      * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
        !            40:      * is less than three, this algorithm will not work!
        !            41:      *
        !            42:      * NB: for the kernel we assert that the shortest two call sequence is:
        !            43:      *
        !            44:      *         calls   $0,_name
        !            45:      *         calls   $0,_name
        !            46:      *
        !            47:      * which is separated by seven bytes, thus HASHFRACTION is calculated as:
        !            48:      *
        !            49:      *         HASHFRACTION = 7 / (2 * 2 - 1) = 2
        !            50:      */
        !            51: #define        HASHFRACTION    2
        !            52: 
        !            53:     /*
        !            54:      * percent of text space to allocate for tostructs
        !            55:      * with a minimum.
        !            56:      */
        !            57: #define ARCDENSITY     2
        !            58: #define MINARCS                50
        !            59: 
        !            60: struct tostruct {
        !            61:     char               *selfpc;
        !            62:     long               count;
        !            63:     unsigned short     link;
        !            64: };
        !            65: 
        !            66:     /*
        !            67:      * a raw arc,
        !            68:      *     with pointers to the calling site and the called site
        !            69:      *     and a count.
        !            70:      */
        !            71: struct rawarc {
        !            72:     unsigned long      raw_frompc;
        !            73:     unsigned long      raw_selfpc;
        !            74:     long               raw_count;
        !            75: };
        !            76: 
        !            77:     /*
        !            78:      * general rounding functions.
        !            79:      */
        !            80: #define ROUNDDOWN(x,y) (((x)/(y))*(y))
        !            81: #define ROUNDUP(x,y)   ((((x)+(y)-1)/(y))*(y))

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.