gmon.h 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. /*-
  2. * Copyright (c) 1982, 1986, 1992, 1993
  3. * The Regents of the University of California. All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions
  7. * are met:
  8. * 1. Redistributions of source code must retain the above copyright
  9. * notice, this list of conditions and the following disclaimer.
  10. * 2. Redistributions in binary form must reproduce the above copyright
  11. * notice, this list of conditions and the following disclaimer in the
  12. * documentation and/or other materials provided with the distribution.
  13. * 4. Neither the name of the University nor the names of its contributors
  14. * may be used to endorse or promote products derived from this software
  15. * without specific prior written permission.
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20. * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27. * SUCH DAMAGE.
  28. *
  29. * @(#)gmon.h 8.2 (Berkeley) 1/4/94
  30. */
  31. #ifndef _SYS_GMON_H
  32. #define _SYS_GMON_H 1
  33. #include <features.h>
  34. #include <sys/types.h>
  35. /*
  36. * See gmon_out.h for gmon.out format.
  37. */
  38. /* structure emitted by "gcc -a". This must match struct bb in
  39. gcc/libgcc2.c. It is OK for gcc to declare a longer structure as
  40. long as the members below are present. */
  41. struct __bb
  42. {
  43. long zero_word;
  44. const char *filename;
  45. long *counts;
  46. long ncounts;
  47. struct __bb *next;
  48. const unsigned long *addresses;
  49. };
  50. extern struct __bb *__bb_head;
  51. /*
  52. * histogram counters are unsigned shorts (according to the kernel).
  53. */
  54. #define HISTCOUNTER unsigned short
  55. /*
  56. * fraction of text space to allocate for histogram counters here, 1/2
  57. */
  58. #define HISTFRACTION 2
  59. /*
  60. * Fraction of text space to allocate for from hash buckets.
  61. * The value of HASHFRACTION is based on the minimum number of bytes
  62. * of separation between two subroutine call points in the object code.
  63. * Given MIN_SUBR_SEPARATION bytes of separation the value of
  64. * HASHFRACTION is calculated as:
  65. *
  66. * HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
  67. *
  68. * For example, on the VAX, the shortest two call sequence is:
  69. *
  70. * calls $0,(r0)
  71. * calls $0,(r0)
  72. *
  73. * which is separated by only three bytes, thus HASHFRACTION is
  74. * calculated as:
  75. *
  76. * HASHFRACTION = 3 / (2 * 2 - 1) = 1
  77. *
  78. * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
  79. * is less than three, this algorithm will not work!
  80. *
  81. * In practice, however, call instructions are rarely at a minimal
  82. * distance. Hence, we will define HASHFRACTION to be 2 across all
  83. * architectures. This saves a reasonable amount of space for
  84. * profiling data structures without (in practice) sacrificing
  85. * any granularity.
  86. */
  87. #define HASHFRACTION 2
  88. /*
  89. * Percent of text space to allocate for tostructs.
  90. * This is a heuristic; we will fail with a warning when profiling programs
  91. * with a very large number of very small functions, but that's
  92. * normally OK.
  93. * 2 is probably still a good value for normal programs.
  94. * Profiling a test case with 64000 small functions will work if
  95. * you raise this value to 3 and link statically (which bloats the
  96. * text size, thus raising the number of arcs expected by the heuristic).
  97. */
  98. #define ARCDENSITY 3
  99. /*
  100. * Always allocate at least this many tostructs. This
  101. * hides the inadequacy of the ARCDENSITY heuristic, at least
  102. * for small programs.
  103. */
  104. #define MINARCS 50
  105. /*
  106. * The type used to represent indices into gmonparam.tos[].
  107. */
  108. #define ARCINDEX u_long
  109. /*
  110. * Maximum number of arcs we want to allow.
  111. * Used to be max representable value of ARCINDEX minus 2, but now
  112. * that ARCINDEX is a long, that's too large; we don't really want
  113. * to allow a 48 gigabyte table.
  114. * The old value of 1<<16 wasn't high enough in practice for large C++
  115. * programs; will 1<<20 be adequate for long? FIXME
  116. */
  117. #define MAXARCS (1 << 20)
  118. struct tostruct {
  119. u_long selfpc;
  120. long count;
  121. ARCINDEX link;
  122. };
  123. /*
  124. * a raw arc, with pointers to the calling site and
  125. * the called site and a count.
  126. */
  127. struct rawarc {
  128. u_long raw_frompc;
  129. u_long raw_selfpc;
  130. long raw_count;
  131. };
  132. /*
  133. * general rounding functions.
  134. */
  135. #define ROUNDDOWN(x,y) (((x)/(y))*(y))
  136. #define ROUNDUP(x,y) ((((x)+(y)-1)/(y))*(y))
  137. /*
  138. * The profiling data structures are housed in this structure.
  139. */
  140. struct gmonparam {
  141. long int state;
  142. u_short *kcount;
  143. u_long kcountsize;
  144. ARCINDEX *froms;
  145. u_long fromssize;
  146. struct tostruct *tos;
  147. u_long tossize;
  148. ARCINDEX tolimit;
  149. u_long lowpc;
  150. u_long highpc;
  151. u_long textsize;
  152. u_long hashfraction;
  153. long log_hashfraction;
  154. };
  155. /*
  156. * Possible states of profiling.
  157. */
  158. #define GMON_PROF_ON 0
  159. #define GMON_PROF_BUSY 1
  160. #define GMON_PROF_ERROR 2
  161. #define GMON_PROF_OFF 3
  162. /*
  163. * Sysctl definitions for extracting profiling information from the kernel.
  164. */
  165. #define GPROF_STATE 0 /* int: profiling enabling variable */
  166. #define GPROF_COUNT 1 /* struct: profile tick count buffer */
  167. #define GPROF_FROMS 2 /* struct: from location hash bucket */
  168. #define GPROF_TOS 3 /* struct: destination/count structure */
  169. #define GPROF_GMONPARAM 4 /* struct: profiling parameters (see above) */
  170. __BEGIN_DECLS
  171. /* Set up data structures and start profiling. */
  172. extern void __monstartup (u_long __lowpc, u_long __highpc) __THROW;
  173. extern void monstartup (u_long __lowpc, u_long __highpc) __THROW;
  174. /* Clean up profiling and write out gmon.out. */
  175. extern void _mcleanup (void) __THROW;
  176. __END_DECLS
  177. #endif /* sys/gmon.h */