Dr Andrew Scott G7VAV

My photo
 
May 2024
Mo Tu We Th Fr Sa Su
29 30 1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31 1 2
3 4 5 6 7 8 9


gmon.h
001: /*-
002:  * Copyright (c) 1982, 1986, 1992, 1993
003:  *      The Regents of the University of California.  All rights reserved.
004:  *
005:  * Redistribution and use in source and binary forms, with or without
006:  * modification, are permitted provided that the following conditions
007:  * are met:
008:  * 1. Redistributions of source code must retain the above copyright
009:  *    notice, this list of conditions and the following disclaimer.
010:  * 2. Redistributions in binary form must reproduce the above copyright
011:  *    notice, this list of conditions and the following disclaimer in the
012:  *    documentation and/or other materials provided with the distribution.
013:  * 4. Neither the name of the University nor the names of its contributors
014:  *    may be used to endorse or promote products derived from this software
015:  *    without specific prior written permission.
016:  *
017:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
018:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
019:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
020:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
021:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
022:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
023:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
024:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
025:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
026:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
027:  * SUCH DAMAGE.
028:  *
029:  *      @(#)gmon.h      8.2 (Berkeley) 1/4/94
030:  */
031: 
032: #ifndef _SYS_GMON_H
033: #define _SYS_GMON_H     1
034: 
035: #include <features.h>
036: 
037: #include <sys/types.h>
038: 
039: /*
040:  * See gmon_out.h for gmon.out format.
041:  */
042: 
043: /* structure emitted by "gcc -a".  This must match struct bb in
044:    gcc/libgcc2.c.  It is OK for gcc to declare a longer structure as
045:    long as the members below are present.  */
046: struct __bb
047: {
048:   long                  zero_word;
049:   const char            *filename;
050:   long                  *counts;
051:   long                  ncounts;
052:   struct __bb           *next;
053:   const unsigned long   *addresses;
054: };
055: 
056: extern struct __bb *__bb_head;
057: 
058: /*
059:  * histogram counters are unsigned shorts (according to the kernel).
060:  */
061: #define HISTCOUNTER     unsigned short
062: 
063: /*
064:  * fraction of text space to allocate for histogram counters here, 1/2
065:  */
066: #define HISTFRACTION    2
067: 
068: /*
069:  * Fraction of text space to allocate for from hash buckets.
070:  * The value of HASHFRACTION is based on the minimum number of bytes
071:  * of separation between two subroutine call points in the object code.
072:  * Given MIN_SUBR_SEPARATION bytes of separation the value of
073:  * HASHFRACTION is calculated as:
074:  *
075:  *      HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
076:  *
077:  * For example, on the VAX, the shortest two call sequence is:
078:  *
079:  *      calls   $0,(r0)
080:  *      calls   $0,(r0)
081:  *
082:  * which is separated by only three bytes, thus HASHFRACTION is
083:  * calculated as:
084:  *
085:  *      HASHFRACTION = 3 / (2 * 2 - 1) = 1
086:  *
087:  * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
088:  * is less than three, this algorithm will not work!
089:  *
090:  * In practice, however, call instructions are rarely at a minimal
091:  * distance.  Hence, we will define HASHFRACTION to be 2 across all
092:  * architectures.  This saves a reasonable amount of space for
093:  * profiling data structures without (in practice) sacrificing
094:  * any granularity.
095:  */
096: #define HASHFRACTION    2
097: 
098: /*
099:  * Percent of text space to allocate for tostructs.
100:  * This is a heuristic; we will fail with a warning when profiling programs
101:  * with a very large number of very small functions, but that's
102:  * normally OK.
103:  * 2 is probably still a good value for normal programs.
104:  * Profiling a test case with 64000 small functions will work if
105:  * you raise this value to 3 and link statically (which bloats the
106:  * text size, thus raising the number of arcs expected by the heuristic).
107:  */
108: #define ARCDENSITY      3
109: 
110: /*
111:  * Always allocate at least this many tostructs.  This
112:  * hides the inadequacy of the ARCDENSITY heuristic, at least
113:  * for small programs.
114:  */
115: #define MINARCS         50
116: 
117: /*
118:  * The type used to represent indices into gmonparam.tos[].
119:  */
120: #define ARCINDEX        u_long
121: 
122: /* 
123:  * Maximum number of arcs we want to allow.
124:  * Used to be max representable value of ARCINDEX minus 2, but now 
125:  * that ARCINDEX is a long, that's too large; we don't really want 
126:  * to allow a 48 gigabyte table.
127:  * The old value of 1<<16 wasn't high enough in practice for large C++
128:  * programs; will 1<<20 be adequate for long?  FIXME
129:  */
130: #define MAXARCS         (1 << 20)
131: 
132: struct tostruct {
133:         u_long          selfpc;
134:         long            count;
135:         ARCINDEX        link;
136: };
137: 
138: /*
139:  * a raw arc, with pointers to the calling site and
140:  * the called site and a count.
141:  */
142: struct rawarc {
143:         u_long  raw_frompc;
144:         u_long  raw_selfpc;
145:         long    raw_count;
146: };
147: 
148: /*
149:  * general rounding functions.
150:  */
151: #define ROUNDDOWN(x,y)  (((x)/(y))*(y))
152: #define ROUNDUP(x,y)    ((((x)+(y)-1)/(y))*(y))
153: 
154: /*
155:  * The profiling data structures are housed in this structure.
156:  */
157: struct gmonparam {
158:         long int        state;
159:         u_short         *kcount;
160:         u_long          kcountsize;
161:         ARCINDEX        *froms;
162:         u_long          fromssize;
163:         struct tostruct *tos;
164:         u_long          tossize;
165:         long            tolimit;
166:         u_long          lowpc;
167:         u_long          highpc;
168:         u_long          textsize;
169:         u_long          hashfraction;
170:         long            log_hashfraction;
171: };
172: 
173: /*
174:  * Possible states of profiling.
175:  */
176: #define GMON_PROF_ON    0
177: #define GMON_PROF_BUSY  1
178: #define GMON_PROF_ERROR 2
179: #define GMON_PROF_OFF   3
180: 
181: /*
182:  * Sysctl definitions for extracting profiling information from the kernel.
183:  */
184: #define GPROF_STATE     0       /* int: profiling enabling variable */
185: #define GPROF_COUNT     1       /* struct: profile tick count buffer */
186: #define GPROF_FROMS     2       /* struct: from location hash bucket */
187: #define GPROF_TOS       3       /* struct: destination/count structure */
188: #define GPROF_GMONPARAM 4       /* struct: profiling parameters (see above) */
189: 
190: __BEGIN_DECLS
191: 
192: /* Set up data structures and start profiling.  */
193: extern void __monstartup (u_long __lowpc, u_long __highpc) __THROW;
194: extern void monstartup (u_long __lowpc, u_long __highpc) __THROW;
195: 
196: /* Clean up profiling and write out gmon.out.  */
197: extern void _mcleanup (void) __THROW;
198: 
199: __END_DECLS
200: 
201: #endif /* sys/gmon.h */
202: 


for client 18.218.55.14
© Andrew Scott 2006 - 2024,
All Rights Reserved
http://www.andrew-scott.uk/
Andrew Scott
http://www.andrew-scott.co.uk/