![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to profile-md.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / profiling / i386|
Return to profile-md.c CVS log | Up to [Apple XNU] / XNU / osfmk / profiling / i386 |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * HISTORY
27: *
28: * Revision 1.1.1.1 1998/09/22 21:05:49 wsanchez
29: * Import of Mac OS X kernel (~semeria)
30: *
31: * Revision 1.1.1.1 1998/03/07 02:26:08 wsanchez
32: * Import of OSF Mach kernel (~mburg)
33: *
34: * Revision 1.1.5.1 1995/01/06 19:53:45 devrcs
35: * mk6 CR668 - 1.3b26 merge
36: * new file for mk6
37: * [1994/10/12 22:25:24 dwm]
38: *
39: * Revision 1.1.2.2 1994/05/16 19:19:22 meissner
40: * Protect against hash_ptr being null in _profile_update_stats.
41: * [1994/05/16 17:23:53 meissner]
42: *
43: * Remove _profile_cnt_to_hex, _profile_strbuffer.
44: * _profile_print_stats now takes const pointers.
45: * Use the new 64-bit arithmetic support instead of converting to double.
46: * Add _profile_merge_stats to merge statistics.
47: * [1994/04/28 21:45:04 meissner]
48: *
49: * If MACH_ASSERT is on in server or kernel, turn on profiling printfs.
50: * Print out fractional digits for average # of hash searches in stats.
51: * Update overflow_ticks for # times the lprofil counter overflows into high word.
52: * Don't make sizes of C/asm structures a const array, since it has pointers in it.
53: * Add support for converting 64 bit ints to a string.
54: * Use PROF_CNT_TO_DECIMAL where possible instead of PROF_CNT_TO_LDOUBLE.
55: * [1994/04/20 15:47:02 meissner]
56: *
57: * Revision 1.1.2.1 1994/04/08 17:51:51 meissner
58: * no change
59: * [1994/04/08 02:11:40 meissner]
60: *
61: * Make most stats 64 bits, except for things like memory allocation.
62: * [1994/04/02 14:58:28 meissner]
63: *
64: * Add some printfs under #idef DEBUG_PROFILE.
65: * [1994/03/29 21:00:11 meissner]
66: *
67: * Further changes for gprof/prof overflow support.
68: * Add overflow support for {gprof,prof,old,dummy}_mcount counters.
69: * [1994/03/17 20:13:31 meissner]
70: *
71: * Add gprof/prof overflow support
72: * [1994/03/17 14:56:51 meissner]
73: *
74: * Use memset instead of bzero.
75: * [1994/02/28 23:56:10 meissner]
76: *
77: * Add size of histogram counters & unused fields to profile_profil struct
78: * [1994/02/17 21:41:50 meissner]
79: *
80: * Allocate slop space for server in addition to microkernel.
81: * Add 3rd argument to _profile_print_stats for profil info.
82: * Print # histogram ticks too low/too high for server/mk.
83: * [1994/02/16 22:38:18 meissner]
84: *
85: * Calculate percentages for # of hash buckets.
86: * [1994/02/11 16:52:04 meissner]
87: *
88: * Print stats as an unsigned number.
89: * [1994/02/07 18:47:05 meissner]
90: *
91: * For kernel and server, include <kern/assert.h> not <assert.h>.
92: * Always do assert on comparing asm vs. C structure sizes.
93: * Add _profile_reset to reset profiling information.
94: * Add _profile_update_stats to update the statistics.
95: * Move _gprof_write code that updates hash stats to _profile_update_stats.
96: * Don't allocate space for basic block support just yet.
97: * Add support for range checking the gprof arc {from,self}pc addresses.
98: * _profile_debug now calls _profile_update_stats.
99: * Print how many times the acontext was locked.
100: * If DEBUG_PROFILE is defined, set pv->debug to 1.
101: * Expand copyright.
102: * [1994/02/07 12:41:03 meissner]
103: *
104: * Keep track of the number of times the kernel overflows the HISTCOUNTER counter.
105: * [1994/02/03 20:13:28 meissner]
106: *
107: * Add stats for {user,kernel,idle} mode in the kernel.
108: * [1994/02/03 15:17:31 meissner]
109: *
110: * Print unused stats in hex as well as decimal.
111: * [1994/02/03 14:52:20 meissner]
112: *
113: * _profile_print_stats no longer takes profile_{vars,md} pointer arguments.
114: * If stream is NULL, _profile_print_stats will use stdout.
115: * Separate _profile_update_stats from _gprof_write.
116: * [1994/02/03 00:58:55 meissner]
117: *
118: * Combine _profile_{vars,stats,md}; Allow more than one _profile_vars.
119: * [1994/02/01 12:04:01 meissner]
120: *
121: * Add allocation flag to _profile_md_init.
122: * Fix core dumps in _profile_print_stats if no profile_vars ptr passed.
123: * Print numbers in 12 columns, not 8.
124: * Print my_cpu/max_cpu if max_cpu != 0.
125: * Make allocations print like other stats.
126: * Use ACONTEXT_FIRST to start loop on, not ACONTEXT_PROF.
127: * [1994/01/28 23:33:26 meissner]
128: *
129: * Move callback pointers into separate allocation context.
130: * Add size fields for other structures to profile-vars.
131: * [1994/01/26 20:23:37 meissner]
132: *
133: * Allocate initial memory at startup.
134: * Print structure sizes and version number when printing stats.
135: * Initialize size fields and version numbers.
136: * Allocation context pointers moved to _profile_vars.
137: * [1994/01/25 01:46:04 meissner]
138: *
139: * Move init code here from assembly language.
140: * [1994/01/22 01:13:21 meissner]
141: *
142: * Include <profile/profile-internal.h> instead of "profile-md.h".
143: * [1994/01/20 20:56:49 meissner]
144: *
145: * Fixup copyright.
146: * [1994/01/18 23:08:02 meissner]
147: *
148: * Rename profile.h -> profile-md.h.
149: * [1994/01/18 19:44:57 meissner]
150: *
151: * Write out stats unused fields.
152: * Make _prof_write write out the prof stats gprof collects.
153: * [1994/01/15 18:40:37 meissner]
154: *
155: * Remove debug code called from profile-asm.s.
156: * Always print out the # of profil buckets.
157: * [1994/01/15 00:59:06 meissner]
158: *
159: * Fix typo.
160: * [1994/01/04 16:34:46 meissner]
161: *
162: * Move max hash bucket calculation into _gprof_write & put info in stats structure.
163: * [1994/01/04 16:15:17 meissner]
164: *
165: * Use _profile_printf to write diagnostics; add diag_stream to hold stream to write to.
166: * [1994/01/04 15:37:46 meissner]
167: *
168: * Correctly handle case where more than one allocation context was
169: * allocated due to multiple threads.
170: * Cast stats to long for output.
171: * Print number of profil buckets field in _profile_stats.
172: * Add support for GFUNC allocation context.
173: * [1994/01/04 14:26:00 meissner]
174: *
175: * CR 10198 - Initial version.
176: * [1994/01/01 22:44:10 meissne
177: *
178: * $EndLog$
179: */
180:
181: #include <profiling/profile-internal.h>
182: #include <stdlib.h>
183: #include <string.h>
184:
185: #if defined(MACH_KERNEL) || defined(_KERNEL)
186:
187: #include <mach_assert.h>
188: #if MACH_ASSERT && !defined(DEBUG_PROFILE)
189: #define DEBUG_PROFILE 1
190: #endif
191:
192: extern int printf(const char *, ...);
193: extern void panic(const char *);
194: #else
195: #include <assert.h>
196: #define panic(str) exit(1)
197: #endif
198:
199: #ifndef PROFILE_NUM_FUNCS
200: #define PROFILE_NUM_FUNCS 2000
201: #endif
202:
203: #ifndef PROFILE_NUM_ARCS
204: #define PROFILE_NUM_ARCS 8000
205: #endif
206:
207: /*
208: * Information passed on from profile-asm.s
209: */
210:
211: extern int _profile_do_stats;
212: extern size_t _profile_size;
213: extern size_t _profile_stats_size;
214: extern size_t _profile_md_size;
215: extern size_t _profile_profil_size;
216: extern size_t _profile_hash_size;
217:
218: /*
219: * All profiling variables, and a dummy gprof record.
220: */
221:
222: struct profile_vars _profile_vars = { 0 };
223: struct hasharc _gprof_dummy = { 0 };
224:
225: /*
226: * Forward references.
227: */
228:
229: static void *_profile_md_acontext(struct profile_vars *pv,
230: void *ptr,
231: size_t len,
232: acontext_type_t type);
233:
234: static void _profile_reset_alloc(struct profile_vars *,
235: acontext_type_t);
236:
237: extern void _bogus_function(void);
238:
239: /*
240: * Function to set up the initial allocation for a context block.
241: */
242:
243: static void *
244: _profile_md_acontext(struct profile_vars *pv,
245: void *ptr,
246: size_t len,
247: acontext_type_t type)
248: {
249: struct memory {
250: struct alloc_context context;
251: struct page_list plist;
252: int data[1];
253: };
254:
255: struct memory *mptr = (struct memory *)ptr;
256: struct alloc_context *context = &mptr->context;
257: struct page_list *plist = &mptr->plist;
258:
259: #ifdef DEBUG_PROFILE
260: _profile_printf("_profile_md_acontext: pv= 0x%lx, ptr= 0x%lx, len= %6ld, type= %d\n",
261: (long)pv,
262: (long)ptr,
263: (long)len,
264: (int)type);
265: #endif
266:
267: /* Fill in context block header */
268: context->next = pv->acontext[type];
269: context->plist = plist;
270: context->lock = 0;
271:
272: /* Fill in first page list information */
273: plist->ptr = plist->first = (void *)&mptr->data[0];
274: plist->next = (struct page_list *)0;
275: plist->bytes_free = len - ((char *)plist->ptr - (char *)ptr);
276: plist->bytes_allocated = 0;
277: plist->num_allocations = 0;
278:
279: /* Update statistics */
280: pv->stats.num_context[type]++;
281: pv->stats.wasted[type] += plist->bytes_free;
282: pv->stats.overhead[type] += len - plist->bytes_free;
283:
284: /* And setup context block */
285: pv->acontext[type] = context;
286:
287: return (void *)((char *)ptr+len);
288: }
289:
290:
291: /*
292: * Machine dependent function to initialize things.
293: */
294:
295: void
296: _profile_md_init(struct profile_vars *pv,
297: profile_type_t type,
298: profile_alloc_mem_t alloc_mem)
299: {
300: size_t page_size = pv->page_size;
301: size_t arc_size;
302: size_t func_size;
303: size_t misc_size;
304: size_t hash_size;
305: size_t extra_arc_size;
306: size_t extra_func_size;
307: size_t callback_size = page_size;
308: void *ptr;
309: acontext_type_t ac;
310: int i;
311: static struct {
312: size_t c_size; /* size C thinks structure is */
313: size_t *asm_size_ptr; /* pointer to size asm thinks struct is */
314: const char *name; /* structure name */
315: } sizes[] = {
316: { sizeof(struct profile_profil), &_profile_profil_size, "profile_profil" },
317: { sizeof(struct profile_stats), &_profile_stats_size, "profile_stats" },
318: { sizeof(struct profile_md), &_profile_md_size, "profile_md" },
319: { sizeof(struct profile_vars), &_profile_size, "profile_vars" }};
320:
321: #ifdef DEBUG_PROFILE
322: _profile_printf("_profile_md_init: pv = 0x%lx, type = %d, alloc = %d\n",
323: (long) pv,
324: (int)type,
325: (int)alloc_mem);
326: #endif
327:
328: for (i = 0; i < sizeof (sizes) / sizeof(sizes[0]); i++) {
329: if (sizes[i].c_size != *sizes[i].asm_size_ptr) {
330: _profile_printf("C thinks struct %s is %ld bytes, asm thinks it is %ld bytes\n",
331: sizes[i].name,
332: (long)sizes[i].c_size,
333: (long)*sizes[i].asm_size_ptr);
334:
335: panic(sizes[i].name);
336: }
337: }
338:
339: /* Figure out which function will handle compiler generated profiling */
340: if (type == PROFILE_GPROF) {
341: pv->md.save_mcount_ptr = _gprof_mcount;
342:
343: } else if (type == PROFILE_PROF) {
344: pv->md.save_mcount_ptr = _prof_mcount;
345:
346: } else {
347: pv->md.save_mcount_ptr = _dummy_mcount;
348: }
349:
350: pv->vars_size = sizeof(struct profile_vars);
351: pv->plist_size = sizeof(struct page_list);
352: pv->acontext_size = sizeof(struct alloc_context);
353: pv->callback_size = sizeof(struct callback);
354: pv->major_version = PROFILE_MAJOR_VERSION;
355: pv->minor_version = PROFILE_MINOR_VERSION;
356: pv->type = type;
357: pv->do_profile = 1;
358: pv->use_dci = 1;
359: pv->use_profil = 1;
360: pv->output_uarea = 1;
361: pv->output_stats = (prof_flag_t) _profile_do_stats;
362: pv->output_clock = 1;
363: pv->multiple_sections = 1;
364: pv->init_format = 0;
365: pv->bogus_func = _bogus_function;
366:
367: #ifdef DEBUG_PROFILE
368: pv->debug = 1;
369: #endif
370:
371: if (!pv->error_msg) {
372: pv->error_msg = "error in profiling";
373: }
374:
375: if (!pv->page_size) {
376: pv->page_size = 4096;
377: }
378:
379: pv->stats.stats_size = sizeof(struct profile_stats);
380: pv->stats.major_version = PROFILE_MAJOR_VERSION;
381: pv->stats.minor_version = PROFILE_MINOR_VERSION;
382:
383: pv->md.md_size = sizeof(struct profile_md);
384: pv->md.major_version = PROFILE_MAJOR_VERSION;
385: pv->md.minor_version = PROFILE_MINOR_VERSION;
386: pv->md.hash_size = _profile_hash_size;
387: pv->md.num_cache = MAX_CACHE;
388: pv->md.mcount_ptr_ptr = &_mcount_ptr;
389: pv->md.dummy_ptr = &_gprof_dummy;
390: pv->md.alloc_pages = _profile_alloc_pages;
391:
392: /* zero out all allocation context blocks */
393: for (ac = ACONTEXT_FIRST; ac < ACONTEXT_MAX; ac++) {
394: pv->acontext[ac] = (struct alloc_context *)0;
395: }
396:
397: /* Don't allocate memory if not desired */
398: if (!alloc_mem) {
399: return;
400: }
401:
402: /* Allocate some space for the initial allocations */
403: switch (type) {
404: default:
405: misc_size = page_size;
406: ptr = _profile_alloc_pages(misc_size + callback_size);
407: ptr = _profile_md_acontext(pv, ptr, misc_size, ACONTEXT_MISC);
408: ptr = _profile_md_acontext(pv, ptr, callback_size, ACONTEXT_CALLBACK);
409: break;
410:
411: case PROFILE_GPROF:
412:
413: #if defined(MACH_KERNEL) || defined(_KERNEL)
414: /*
415: * For the MK & server allocate some slop space now for the
416: * secondary context blocks in case allocations are done at
417: * interrupt level when another allocation is being done. This
418: * is done before the main allocation blocks and will be pushed
419: * so that it will only be used when the main allocation block
420: * is locked.
421: */
422: extra_arc_size = 4*page_size;
423: extra_func_size = 2*page_size;
424: #else
425: extra_arc_size = extra_func_size = 0;
426: #endif
427:
428: /* Set up allocation areas */
429: arc_size = ROUNDUP(PROFILE_NUM_ARCS * sizeof(struct hasharc), page_size);
430: func_size = ROUNDUP(PROFILE_NUM_FUNCS * sizeof(struct gfuncs), page_size);
431: hash_size = _profile_hash_size * sizeof (struct hasharc *);
432: misc_size = ROUNDUP(hash_size + page_size, page_size);
433:
434: ptr = _profile_alloc_pages(arc_size
435: + func_size
436: + misc_size
437: + callback_size
438: + extra_arc_size
439: + extra_func_size);
440:
441: #if defined(MACH_KERNEL) || defined(_KERNEL)
442: ptr = _profile_md_acontext(pv, ptr, extra_arc_size, ACONTEXT_GPROF);
443: ptr = _profile_md_acontext(pv, ptr, extra_func_size, ACONTEXT_GFUNC);
444: #endif
445: ptr = _profile_md_acontext(pv, ptr, arc_size, ACONTEXT_GPROF);
446: ptr = _profile_md_acontext(pv, ptr, func_size, ACONTEXT_GFUNC);
447: ptr = _profile_md_acontext(pv, ptr, misc_size, ACONTEXT_MISC);
448: ptr = _profile_md_acontext(pv, ptr, callback_size, ACONTEXT_CALLBACK);
449:
450: /* Allocate hash table */
451: pv->md.hash_ptr = (struct hasharc **) _profile_alloc(pv, hash_size, ACONTEXT_MISC);
452: break;
453:
454: case PROFILE_PROF:
455: /* Set up allocation areas */
456: func_size = ROUNDUP(PROFILE_NUM_FUNCS * sizeof(struct prof_ext), page_size);
457: misc_size = page_size;
458:
459: ptr = _profile_alloc_pages(func_size
460: + misc_size
461: + callback_size);
462:
463: ptr = _profile_md_acontext(pv, ptr, func_size, ACONTEXT_PROF);
464: ptr = _profile_md_acontext(pv, ptr, misc_size, ACONTEXT_MISC);
465: ptr = _profile_md_acontext(pv, ptr, callback_size, ACONTEXT_CALLBACK);
466: break;
467: }
468: }
469:
470:
471: /*
472: * Machine dependent functions to start and stop profiling.
473: */
474:
475: int
476: _profile_md_start(void)
477: {
478: _mcount_ptr = _profile_vars.md.save_mcount_ptr;
479: return 0;
480: }
481:
482: int
483: _profile_md_stop(void)
484: {
485: _mcount_ptr = _dummy_mcount;
486: return 0;
487: }
488:
489:
490: /*
491: * Free up all memory in a memory context block.
492: */
493:
494: static void
495: _profile_reset_alloc(struct profile_vars *pv, acontext_type_t ac)
496: {
497: struct alloc_context *aptr;
498: struct page_list *plist;
499:
500: for (aptr = pv->acontext[ac];
501: aptr != (struct alloc_context *)0;
502: aptr = aptr->next) {
503:
504: for (plist = aptr->plist;
505: plist != (struct page_list *)0;
506: plist = plist->next) {
507:
508: plist->ptr = plist->first;
509: plist->bytes_free += plist->bytes_allocated;
510: plist->bytes_allocated = 0;
511: plist->num_allocations = 0;
512: memset(plist->first, '\0', plist->bytes_allocated);
513: }
514: }
515: }
516:
517:
518: /*
519: * Reset profiling. Since the only user of this function is the kernel
520: * and the server, we don't have to worry about other stuff than gprof.
521: */
522:
523: void
524: _profile_reset(struct profile_vars *pv)
525: {
526: struct alloc_context *aptr;
527: struct page_list *plist;
528: struct gfuncs *gfunc;
529:
530: if (pv->active) {
531: _profile_md_stop();
532: }
533:
534: /* Reset all function unique pointers back to 0 */
535: for (aptr = pv->acontext[ACONTEXT_GFUNC];
536: aptr != (struct alloc_context *)0;
537: aptr = aptr->next) {
538:
539: for (plist = aptr->plist;
540: plist != (struct page_list *)0;
541: plist = plist->next) {
542:
543: for (gfunc = (struct gfuncs *)plist->first;
544: gfunc < (struct gfuncs *)plist->ptr;
545: gfunc++) {
546:
547: *(gfunc->unique_ptr) = (struct hasharc *)0;
548: }
549: }
550: }
551:
552: /* Release memory */
553: _profile_reset_alloc(pv, ACONTEXT_GPROF);
554: _profile_reset_alloc(pv, ACONTEXT_GFUNC);
555: _profile_reset_alloc(pv, ACONTEXT_PROF);
556:
557: memset((void *)pv->profil_buf, '\0', pv->profil_info.profil_len);
558: memset((void *)pv->md.hash_ptr, '\0', pv->md.hash_size * sizeof(struct hasharc *));
559: memset((void *)&pv->stats, '\0', sizeof(pv->stats));
560:
561: pv->stats.stats_size = sizeof(struct profile_stats);
562: pv->stats.major_version = PROFILE_MAJOR_VERSION;
563: pv->stats.minor_version = PROFILE_MINOR_VERSION;
564:
565: if (pv->active) {
566: _profile_md_start();
567: }
568: }
569:
570:
571: /*
572: * Machine dependent function to write out gprof records.
573: */
574:
575: size_t
576: _gprof_write(struct profile_vars *pv, struct callback *callback_ptr)
577: {
578: struct alloc_context *aptr;
579: struct page_list *plist;
580: size_t bytes = 0;
581: struct hasharc *hptr;
582: int i;
583:
584: for (aptr = pv->acontext[ACONTEXT_GPROF];
585: aptr != (struct alloc_context *)0;
586: aptr = aptr->next) {
587:
588: for (plist = aptr->plist; plist != (struct page_list *)0; plist = plist->next) {
589: hptr = (struct hasharc *)plist->first;
590: for (i = 0; i < plist->num_allocations; (i++, hptr++)) {
591:
592: struct gprof_arc arc = hptr->arc;
593: int nrecs = 1 + (hptr->overflow * 2);
594: int j;
595:
596: if (pv->check_funcs) {
597: if (arc.frompc < pv->profil_info.lowpc ||
598: arc.frompc > pv->profil_info.highpc) {
599:
600: arc.frompc = (prof_uptrint_t)pv->bogus_func;
601: }
602:
603: if (arc.selfpc < pv->profil_info.lowpc ||
604: arc.selfpc > pv->profil_info.highpc) {
605:
606: arc.selfpc = (prof_uptrint_t)pv->bogus_func;
607: }
608: }
609:
610: /* For each overflow, emit 2 extra records with the count
611: set to 0x80000000 */
612: for (j = 0; j < nrecs; j++) {
613: bytes += sizeof (arc);
614: if ((*pv->fwrite_func)((void *)&arc,
615: sizeof(arc),
616: 1,
617: pv->stream) != 1) {
618:
619: _profile_error(pv);
620: }
621:
622: arc.count = 0x80000000;
623: }
624: }
625: }
626: }
627:
628: return bytes;
629: }
630:
631:
632: /*
633: * Machine dependent function to write out prof records.
634: */
635:
636: size_t
637: _prof_write(struct profile_vars *pv, struct callback *callback_ptr)
638: {
639: struct alloc_context *aptr;
640: struct page_list *plist;
641: size_t bytes = 0;
642: struct prof_ext prof_st;
643: struct prof_int *pptr;
644: struct gfuncs *gptr;
645: int nrecs;
646: int i, j;
647:
648: /* Write out information prof_mcount collects */
649: for (aptr = pv->acontext[ACONTEXT_PROF];
650: aptr != (struct alloc_context *)0;
651: aptr = aptr->next) {
652:
653: for (plist = aptr->plist; plist != (struct page_list *)0; plist = plist->next) {
654: pptr = (struct prof_int *)plist->first;
655:
656: for (i = 0; i < plist->num_allocations; (i++, pptr++)) {
657:
658: /* Write out 2 records for each overflow, each with a
659: count of 0x80000000 + the normal record */
660: prof_st = pptr->prof;
661: nrecs = 1 + (pptr->overflow * 2);
662:
663: for (j = 0; j < nrecs; j++) {
664: bytes += sizeof (struct prof_ext);
665: if ((*pv->fwrite_func)((void *)&prof_st,
666: sizeof(prof_st),
667: 1,
668: pv->stream) != 1) {
669:
670: _profile_error(pv);
671: }
672:
673: prof_st.cncall = 0x80000000;
674: }
675: }
676: }
677: }
678:
679: /* Now write out the prof information that gprof collects */
680: for (aptr = pv->acontext[ACONTEXT_GFUNC];
681: aptr != (struct alloc_context *)0;
682: aptr = aptr->next) {
683:
684: for (plist = aptr->plist; plist != (struct page_list *)0; plist = plist->next) {
685: gptr = (struct gfuncs *)plist->first;
686:
687: for (i = 0; i < plist->num_allocations; (i++, gptr++)) {
688:
689: /* Write out 2 records for each overflow, each with a
690: count of 0x80000000 + the normal record */
691: prof_st = gptr->prof.prof;
692: nrecs = 1 + (gptr->prof.overflow * 2);
693:
694: for (j = 0; j < nrecs; j++) {
695: bytes += sizeof (struct prof_ext);
696: if ((*pv->fwrite_func)((void *)&prof_st,
697: sizeof(prof_st),
698: 1,
699: pv->stream) != 1) {
700:
701: _profile_error(pv);
702: }
703:
704: prof_st.cncall = 0x80000000;
705: }
706: }
707: }
708: }
709:
710: return bytes;
711: }
712:
713:
714: /*
715: * Update any statistics. For the 386, calculate the hash table loading factor.
716: * Also figure out how many overflows occured.
717: */
718:
719: void
720: _profile_update_stats(struct profile_vars *pv)
721: {
722: struct alloc_context *aptr;
723: struct page_list *plist;
724: struct hasharc *hptr;
725: struct prof_int *pptr;
726: struct gfuncs *fptr;
727: LHISTCOUNTER *lptr;
728: int i;
729:
730: for(i = 0; i < MAX_BUCKETS+1; i++) {
731: pv->stats.buckets[i] = 0;
732: }
733:
734: pv->stats.hash_buckets = 0;
735:
736: if (pv->md.hash_ptr) {
737: for (i = 0; i < pv->md.hash_size; i++) {
738: long nbuckets = 0;
739: struct hasharc *hptr;
740:
741: for (hptr = pv->md.hash_ptr[i]; hptr; hptr = hptr->next) {
742: nbuckets++;
743: }
744:
745: pv->stats.buckets[ (nbuckets < MAX_BUCKETS) ? nbuckets : MAX_BUCKETS ]++;
746: if (pv->stats.hash_buckets < nbuckets) {
747: pv->stats.hash_buckets = nbuckets;
748: }
749: }
750: }
751:
752: /* Count how many times functions are out of bounds */
753: if (pv->check_funcs) {
754: pv->stats.bogus_count = 0;
755:
756: for (aptr = pv->acontext[ACONTEXT_GPROF];
757: aptr != (struct alloc_context *)0;
758: aptr = aptr->next) {
759:
760: for (plist = aptr->plist;
761: plist != (struct page_list *)0;
762: plist = plist->next) {
763:
764: hptr = (struct hasharc *)plist->first;
765: for (i = 0; i < plist->num_allocations; (i++, hptr++)) {
766:
767: if (hptr->arc.frompc < pv->profil_info.lowpc ||
768: hptr->arc.frompc > pv->profil_info.highpc) {
769: pv->stats.bogus_count++;
770: }
771:
772: if (hptr->arc.selfpc < pv->profil_info.lowpc ||
773: hptr->arc.selfpc > pv->profil_info.highpc) {
774: pv->stats.bogus_count++;
775: }
776: }
777: }
778: }
779: }
780:
781: /* Figure out how many overflows occurred */
782: PROF_ULONG_TO_CNT(pv->stats.prof_overflow, 0);
783: PROF_ULONG_TO_CNT(pv->stats.gprof_overflow, 0);
784:
785: for (aptr = pv->acontext[ACONTEXT_GPROF];
786: aptr != (struct alloc_context *)0;
787: aptr = aptr->next) {
788:
789: for (plist = aptr->plist;
790: plist != (struct page_list *)0;
791: plist = plist->next) {
792:
793: hptr = (struct hasharc *)plist->first;
794: for (i = 0; i < plist->num_allocations; (i++, hptr++)) {
795: PROF_CNT_ADD(pv->stats.gprof_overflow, hptr->overflow);
796: }
797: }
798: }
799:
800: for (aptr = pv->acontext[ACONTEXT_PROF];
801: aptr != (struct alloc_context *)0;
802: aptr = aptr->next) {
803:
804: for (plist = aptr->plist;
805: plist != (struct page_list *)0;
806: plist = plist->next) {
807:
808: pptr = (struct prof_int *)plist->first;
809: for (i = 0; i < plist->num_allocations; (i++, pptr++)) {
810: PROF_CNT_ADD(pv->stats.prof_overflow, pptr->overflow);
811: }
812: }
813: }
814:
815: for (aptr = pv->acontext[ACONTEXT_GFUNC];
816: aptr != (struct alloc_context *)0;
817: aptr = aptr->next) {
818:
819: for (plist = aptr->plist;
820: plist != (struct page_list *)0;
821: plist = plist->next) {
822:
823: fptr = (struct gfuncs *)plist->first;
824: for (i = 0; i < plist->num_allocations; (i++, fptr++)) {
825: PROF_CNT_ADD(pv->stats.prof_overflow, fptr->prof.overflow);
826: }
827: }
828: }
829:
830: /* Now go through & count how many times the LHISTCOUNTER overflowed into a 2nd word */
831: lptr = (LHISTCOUNTER *)pv->profil_buf;
832:
833: if (pv->use_profil &&
834: pv->profil_info.counter_size == sizeof(LHISTCOUNTER) &&
835: lptr != (LHISTCOUNTER *)0) {
836:
837: PROF_ULONG_TO_CNT(pv->stats.overflow_ticks, 0);
838: for (i = 0; i < pv->stats.profil_buckets; i++) {
839: PROF_CNT_ADD(pv->stats.overflow_ticks, lptr[i].high);
840: }
841: }
842: }
843:
844: #if !defined(_KERNEL) && !defined(MACH_KERNEL)
845:
846: /*
847: * Routine callable from the debugger that prints the statistics.
848: */
849:
850: int _profile_debug(void)
851: {
852: _profile_update_stats(&_profile_vars);
853: _profile_print_stats(stderr, &_profile_vars.stats, &_profile_vars.profil_info);
854: return 0;
855: }
856:
857: /*
858: * Print the statistics structure in a meaningful way.
859: */
860:
861: void _profile_print_stats(FILE *stream,
862: const struct profile_stats *stats,
863: const struct profile_profil *pinfo)
864: {
865: int i;
866: prof_cnt_t total_hits;
867: acontext_type_t ac;
868: int width_cname = 0;
869: int width_alloc = 0;
870: int width_wasted = 0;
871: int width_overhead = 0;
872: int width_context = 0;
873: static const char *cname[ACONTEXT_MAX] = ACONTEXT_NAMES;
874: char buf[20];
875:
876: if (!stats) {
877: return;
878: }
879:
880: if (!stream) {
881: stream = stdout;
882: }
883:
884: sprintf(buf, "%ld.%ld", (long)stats->major_version, (long)stats->minor_version);
885: fprintf(stream, "%12s profiling version number\n", buf);
886: fprintf(stream, "%12lu size of profile_vars\n", (long unsigned)sizeof(struct profile_vars));
887: fprintf(stream, "%12lu size of profile_stats\n", (long unsigned)sizeof(struct profile_stats));
888: fprintf(stream, "%12lu size of profile_md\n", (long unsigned)sizeof(struct profile_md));
889: fprintf(stream, "%12s calls to _{,g}prof_mcount\n", PROF_CNT_TO_DECIMAL((char *)0, stats->cnt));
890: fprintf(stream, "%12s calls to old mcount\n", PROF_CNT_TO_DECIMAL((char *)0, stats->old_mcount));
891: fprintf(stream, "%12s calls to _dummy_mcount\n", PROF_CNT_TO_DECIMAL((char *)0, stats->dummy));
892: fprintf(stream, "%12lu functions profiled\n", (long unsigned)stats->prof_records);
893: fprintf(stream, "%12lu gprof arcs\n", (long unsigned)stats->gprof_records);
894:
895: if (pinfo) {
896: fprintf(stream, "%12lu profil buckets\n", (long unsigned)stats->profil_buckets);
897: fprintf(stream, "%12lu profil lowpc [0x%lx]\n",
898: (long unsigned)pinfo->lowpc,
899: (long unsigned)pinfo->lowpc);
900:
901: fprintf(stream, "%12lu profil highpc [0x%lx]\n",
902: (long unsigned)pinfo->highpc,
903: (long unsigned)pinfo->highpc);
904:
905: fprintf(stream, "%12lu profil highpc-lowpc\n", (long unsigned)(pinfo->highpc - pinfo->lowpc));
906: fprintf(stream, "%12lu profil buffer length\n", (long unsigned)pinfo->profil_len);
907: fprintf(stream, "%12lu profil sizeof counters\n", (long unsigned)pinfo->counter_size);
908: fprintf(stream, "%12lu profil scale (%g)\n",
909: (long unsigned)pinfo->scale,
910: ((double)pinfo->scale) / ((double) 0x10000));
911:
912:
913: for (i = 0; i < sizeof (pinfo->profil_unused) / sizeof (pinfo->profil_unused[0]); i++) {
914: if (pinfo->profil_unused[i]) {
915: fprintf(stream, "%12lu profil unused[%2d] {0x%.8lx}\n",
916: (long unsigned)pinfo->profil_unused[i],
917: i,
918: (long unsigned)pinfo->profil_unused[i]);
919: }
920: }
921: }
922:
923: if (stats->max_cpu) {
924: fprintf(stream, "%12lu current cpu/thread\n", (long unsigned)stats->my_cpu);
925: fprintf(stream, "%12lu max cpu/thread+1\n", (long unsigned)stats->max_cpu);
926: }
927:
928: if (stats->bogus_count != 0) {
929: fprintf(stream,
930: "%12lu gprof functions found outside of range\n",
931: (long unsigned)stats->bogus_count);
932: }
933:
934: if (PROF_CNT_NE_0(stats->too_low)) {
935: fprintf(stream,
936: "%12s histogram ticks were too low\n",
937: PROF_CNT_TO_DECIMAL((char *)0, stats->too_low));
938: }
939:
940: if (PROF_CNT_NE_0(stats->too_high)) {
941: fprintf(stream,
942: "%12s histogram ticks were too high\n",
943: PROF_CNT_TO_DECIMAL((char *)0, stats->too_high));
944: }
945:
946: if (PROF_CNT_NE_0(stats->acontext_locked)) {
947: fprintf(stream,
948: "%12s times an allocation context was locked\n",
949: PROF_CNT_TO_DECIMAL((char *)0, stats->acontext_locked));
950: }
951:
952: if (PROF_CNT_NE_0(stats->kernel_ticks)
953: || PROF_CNT_NE_0(stats->user_ticks)
954: || PROF_CNT_NE_0(stats->idle_ticks)) {
955:
956: prof_cnt_t total_ticks;
957: long double total_ticks_dbl;
958:
959: total_ticks = stats->kernel_ticks;
960: PROF_CNT_LADD(total_ticks, stats->user_ticks);
961: PROF_CNT_LADD(total_ticks, stats->idle_ticks);
962: total_ticks_dbl = PROF_CNT_TO_LDOUBLE(total_ticks);
963:
964: fprintf(stream,
965: "%12s total ticks\n",
966: PROF_CNT_TO_DECIMAL((char *)0, total_ticks));
967:
968: fprintf(stream,
969: "%12s ticks within the kernel (%5.2Lf%%)\n",
970: PROF_CNT_TO_DECIMAL((char *)0, stats->kernel_ticks),
971: 100.0L * (PROF_CNT_TO_LDOUBLE(stats->kernel_ticks) / total_ticks_dbl));
972:
973: fprintf(stream,
974: "%12s ticks within user space (%5.2Lf%%)\n",
975: PROF_CNT_TO_DECIMAL((char *)0, stats->user_ticks),
976: 100.0L * (PROF_CNT_TO_LDOUBLE(stats->user_ticks) / total_ticks_dbl));
977:
978: fprintf(stream,
979: "%12s ticks idle (%5.2Lf%%)\n",
980: PROF_CNT_TO_DECIMAL((char *)0, stats->idle_ticks),
981: 100.0L * (PROF_CNT_TO_LDOUBLE(stats->idle_ticks) / total_ticks_dbl));
982: }
983:
984: if (PROF_CNT_NE_0(stats->overflow_ticks)) {
985: fprintf(stream, "%12s times a HISTCOUNTER counter would have overflowed\n",
986: PROF_CNT_TO_DECIMAL((char *)0, stats->overflow_ticks));
987: }
988:
989: if (PROF_CNT_NE_0(stats->hash_num)) {
990: long double total_buckets = 0.0L;
991:
992: for (i = 0; i <= MAX_BUCKETS; i++) {
993: total_buckets += (long double)stats->buckets[i];
994: }
995:
996: fprintf(stream, "%12lu max bucket(s) on hash chain.\n", (long unsigned)stats->hash_buckets);
997: for (i = 0; i < MAX_BUCKETS; i++) {
998: if (stats->buckets[i] != 0) {
999: fprintf(stream, "%12lu bucket(s) had %d entries (%5.2Lf%%)\n",
1000: (long unsigned)stats->buckets[i], i,
1001: 100.0L * ((long double)stats->buckets[i] / total_buckets));
1002: }
1003: }
1004:
1005: if (stats->buckets[MAX_BUCKETS] != 0) {
1006: fprintf(stream, "%12lu bucket(s) had more than %d entries (%5.2Lf%%)\n",
1007: (long unsigned)stats->buckets[MAX_BUCKETS], MAX_BUCKETS,
1008: 100.0L * ((long double)stats->buckets[MAX_BUCKETS] / total_buckets));
1009: }
1010: }
1011:
1012: PROF_ULONG_TO_CNT(total_hits, 0);
1013: for (i = 0; i < MAX_CACHE; i++) {
1014: PROF_CNT_LADD(total_hits, stats->cache_hits[i]);
1015: }
1016:
1017: if (PROF_CNT_NE_0(total_hits)) {
1018: long double total = PROF_CNT_TO_LDOUBLE(stats->cnt);
1019: long double total_hits_dbl = PROF_CNT_TO_LDOUBLE(total_hits);
1020:
1021: fprintf(stream,
1022: "%12s cache hits (%.2Lf%%)\n",
1023: PROF_CNT_TO_DECIMAL((char *)0, total_hits),
1024: 100.0L * (total_hits_dbl / total));
1025:
1026: for (i = 0; i < MAX_CACHE; i++) {
1027: if (PROF_CNT_NE_0(stats->cache_hits[i])) {
1028: fprintf(stream,
1029: "%12s times cache#%d matched (%5.2Lf%% of cache hits, %5.2Lf%% total)\n",
1030: PROF_CNT_TO_DECIMAL((char *)0, stats->cache_hits[i]),
1031: i+1,
1032: 100.0L * (PROF_CNT_TO_LDOUBLE(stats->cache_hits[i]) / total_hits_dbl),
1033: 100.0L * (PROF_CNT_TO_LDOUBLE(stats->cache_hits[i]) / total));
1034: }
1035: }
1036:
1037: if (PROF_CNT_NE_0(stats->hash_num)) {
1038: fprintf(stream, "%12s times hash table searched\n", PROF_CNT_TO_DECIMAL((char *)0, stats->hash_num));
1039: fprintf(stream, "%12s hash buckets searched\n", PROF_CNT_TO_DECIMAL((char *)0, stats->hash_search));
1040: fprintf(stream, "%12.4Lf average buckets searched\n",
1041: PROF_CNT_TO_LDOUBLE(stats->hash_search) / PROF_CNT_TO_LDOUBLE(stats->hash_num));
1042: }
1043: }
1044:
1045: for (i = 0; i < sizeof (stats->stats_unused) / sizeof (stats->stats_unused[0]); i++) {
1046: if (PROF_CNT_NE_0(stats->stats_unused[i])) {
1047: fprintf(stream, "%12s unused[%2d] {0x%.8lx 0x%.8lx}\n",
1048: PROF_CNT_TO_DECIMAL((char *)0, stats->stats_unused[i]),
1049: i,
1050: (unsigned long)stats->stats_unused[i].high,
1051: (unsigned long)stats->stats_unused[i].low);
1052: }
1053: }
1054:
1055: /* Get the width for the allocation contexts */
1056: for (ac = ACONTEXT_FIRST; ac < ACONTEXT_MAX; ac++) {
1057: int len;
1058:
1059: if (stats->num_context[ac] == 0) {
1060: continue;
1061: }
1062:
1063: len = strlen (cname[ac]);
1064: if (len > width_cname)
1065: width_cname = len;
1066:
1067: len = sprintf (buf, "%lu", (long unsigned)stats->num_alloc[ac]);
1068: if (len > width_alloc)
1069: width_alloc = len;
1070:
1071: len = sprintf (buf, "%lu", (long unsigned)stats->wasted[ac]);
1072: if (len > width_wasted)
1073: width_wasted = len;
1074:
1075: len = sprintf (buf, "%lu", (long unsigned)stats->overhead[ac]);
1076: if (len > width_overhead)
1077: width_overhead = len;
1078:
1079: len = sprintf (buf, "%lu", (long unsigned)stats->num_context[ac]);
1080: if (len > width_context)
1081: width_context = len;
1082: }
1083:
1084: /* Print info about allocation contexts */
1085: for (ac = ACONTEXT_FIRST; ac < ACONTEXT_MAX; ac++) {
1086: if (stats->num_context[ac] == 0) {
1087: continue;
1088: }
1089:
1090: fprintf (stream,
1091: "%12lu bytes in %-*s %*lu alloc, %*lu unused, %*lu over, %*lu context\n",
1092: (long unsigned)stats->bytes_alloc[ac],
1093: width_cname, cname[ac],
1094: width_alloc, (long unsigned)stats->num_alloc[ac],
1095: width_wasted, (long unsigned)stats->wasted[ac],
1096: width_overhead, (long unsigned)stats->overhead[ac],
1097: width_context, (long unsigned)stats->num_context[ac]);
1098: }
1099: }
1100:
1101:
1102: /*
1103: * Merge a new statistics field into an old one.
1104: */
1105:
1106: void _profile_merge_stats(struct profile_stats *old_stats, const struct profile_stats *new_stats)
1107: {
1108: int i;
1109:
1110: /* If nothing passed, just return */
1111: if (!old_stats || !new_stats)
1112: return;
1113:
1114: /* If the old_stats has not been initialized, just copy in the new stats */
1115: if (old_stats->major_version == 0) {
1116: *old_stats = *new_stats;
1117:
1118: /* Otherwise, update stats, field by field */
1119: } else {
1120: if (old_stats->prof_records < new_stats->prof_records)
1121: old_stats->prof_records = new_stats->prof_records;
1122:
1123: if (old_stats->gprof_records < new_stats->gprof_records)
1124: old_stats->gprof_records = new_stats->gprof_records;
1125:
1126: if (old_stats->hash_buckets < new_stats->hash_buckets)
1127: old_stats->hash_buckets = new_stats->hash_buckets;
1128:
1129: if (old_stats->bogus_count < new_stats->bogus_count)
1130: old_stats->bogus_count = new_stats->bogus_count;
1131:
1132: PROF_CNT_LADD(old_stats->cnt, new_stats->cnt);
1133: PROF_CNT_LADD(old_stats->dummy, new_stats->dummy);
1134: PROF_CNT_LADD(old_stats->old_mcount, new_stats->old_mcount);
1135: PROF_CNT_LADD(old_stats->hash_search, new_stats->hash_search);
1136: PROF_CNT_LADD(old_stats->hash_num, new_stats->hash_num);
1137: PROF_CNT_LADD(old_stats->user_ticks, new_stats->user_ticks);
1138: PROF_CNT_LADD(old_stats->kernel_ticks, new_stats->kernel_ticks);
1139: PROF_CNT_LADD(old_stats->idle_ticks, new_stats->idle_ticks);
1140: PROF_CNT_LADD(old_stats->overflow_ticks, new_stats->overflow_ticks);
1141: PROF_CNT_LADD(old_stats->acontext_locked, new_stats->acontext_locked);
1142: PROF_CNT_LADD(old_stats->too_low, new_stats->too_low);
1143: PROF_CNT_LADD(old_stats->too_high, new_stats->too_high);
1144: PROF_CNT_LADD(old_stats->prof_overflow, new_stats->prof_overflow);
1145: PROF_CNT_LADD(old_stats->gprof_overflow, new_stats->gprof_overflow);
1146:
1147: for (i = 0; i < (int)ACONTEXT_MAX; i++) {
1148: if (old_stats->num_alloc[i] < new_stats->num_alloc[i])
1149: old_stats->num_alloc[i] = new_stats->num_alloc[i];
1150:
1151: if (old_stats->bytes_alloc[i] < new_stats->bytes_alloc[i])
1152: old_stats->bytes_alloc[i] = new_stats->bytes_alloc[i];
1153:
1154: if (old_stats->num_context[i] < new_stats->num_context[i])
1155: old_stats->num_context[i] = new_stats->num_context[i];
1156:
1157: if (old_stats->wasted[i] < new_stats->wasted[i])
1158: old_stats->wasted[i] = new_stats->wasted[i];
1159:
1160: if (old_stats->overhead[i] < new_stats->overhead[i])
1161: old_stats->overhead[i] = new_stats->overhead[i];
1162:
1163: }
1164:
1165: for (i = 0; i < MAX_BUCKETS+1; i++) {
1166: if (old_stats->buckets[i] < new_stats->buckets[i])
1167: old_stats->buckets[i] = new_stats->buckets[i];
1168: }
1169:
1170: for (i = 0; i < MAX_CACHE; i++) {
1171: PROF_CNT_LADD(old_stats->cache_hits[i], new_stats->cache_hits[i]);
1172: }
1173:
1174: for (i = 0; i < sizeof(old_stats->stats_unused) / sizeof(old_stats->stats_unused[0]); i++) {
1175: PROF_CNT_LADD(old_stats->stats_unused[i], new_stats->stats_unused[i]);
1176: }
1177: }
1178: }
1179:
1180: #endif
1181:
1182:
1183: /*
1184: * Invalid function address used when checking of function addresses is
1185: * desired for gprof arcs, and we discover an address out of bounds.
1186: * There should be no callers of this function.
1187: */
1188:
1189: void
1190: _bogus_function(void)
1191: {
1192: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.