comparison src/backtrace.h @ 1292:f3437b56874d

[xemacs-hg @ 2003-02-13 09:57:04 by ben] profile updates profile.c: Major reworking. Keep track of new information -- total function timing (includes descendants), GC usage, total GC usage (includes descendants). New functions to be called appropriately from eval.c, alloc.c to keep track of this information. Keep track of when we're actually in a function vs. in its profile, for more accurate timing counts. Track profile overhead separately. Create new mechanism for specifying "internal sections" that are tracked just like regular Lisp functions and even appear in the backtrace if `backtrace-with-internal-sections' is non-nil (t by default for error-checking builds). Add some KKCC information for the straight (non-Elisp) hash table used by profile, which contains Lisp objects in its keys -- but not used yet. Remove old ad-hoc methods for tracking garbage collection, redisplay (which was incorrect anyway when Lisp was called within these sections). Don't record any tick info when blocking under MS Windows, since the timer there is in real time rather than in process time. Make `start-profiling', `stop-profiling' interactive. Be consistent wrt. recursive functions and functions currently on the stack when starting or stopping -- together these make implementing the `total' values extremely difficult. When we start profiling, we act as if we just entered all the functions currently on the stack. Likewise when exiting. Create vars in_profile for tracking time spent inside of profiling, and profiling_lock for setting exclusive access to the main hash table when reading from it or modifying it. (protects against getting screwed up by the signal handle going off at the same time. profile.h: New file. Create macros for declaring internal profiling sections. lisp.h: Move profile-related stuff to profile.h. alloc.c: Keep track of total consing, for profile. Tell profile when we are consing. Use new profile-section method for noting garbage-collection. alloc.c: Abort if we attempt to call the allocator reentrantly. backtrace.h, eval.c: Add info for use by profile in the backtrace frame and transfer PUSH_BACKTRACE/POP_BACKTRACE from eval.c, for use with profile. elhash.c: Author comment. eval.c, lisp.h: New Lisp var `backtrace-with-internal-sections'. Set to t when error-checking is on. eval.c: When unwinding, eval.c: Report to profile when we are about-to-call and just-called wrt. a function. alloc.c, eval.c: Allow for "fake" backtrace frames, for internal sections (used by profile and `backtrace-with-internal-sections'. event-Xt.c, event-gtk.c, event-msw.c, event-tty.c: Record when we are actually blocking on an event, for profile's sake. event-stream.c: Record internal profiling sections for getting, dispatching events. extents.c: Record internal profiling sections for map_extents. hash.c, hash.h: Add pregrow_hash_table_if_necessary(). (Used in profile code since the signal handler is the main grower but can't allow a realloc(). We make sure, at critical points, that the table is large enough.) lread.c: Create internal profiling sections for `load' (which may be triggered internally by autoload, etc.). redisplay.c: Remove old profile_redisplay_flag. Use new macros to declare internal profiling section for redisplay. text.c: Use new macros to declare internal profiling sections for char-byte conversion and internal-external conversion. SEMI-UNRELATED CHANGES: ----------------------- text.c: Update the long comments.
author ben
date Thu, 13 Feb 2003 09:57:08 +0000
parents 2b6fa2618f76
children 989a7680c221
comparison
equal deleted inserted replaced
1291:3d99b5e6c6ec 1292:f3437b56874d
1 /* The lisp stack. 1 /* The lisp stack.
2 Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc. 2 Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc.
3 Copyright (C) 2002 Ben Wing. 3 Copyright (C) 2002, 2003 Ben Wing.
4 4
5 This file is part of XEmacs. 5 This file is part of XEmacs.
6 6
7 XEmacs is free software; you can redistribute it and/or modify it 7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the 8 under the terms of the GNU General Public License as published by the
61 slot holding list of unevalled args */ 61 slot holding list of unevalled args */
62 int pdlcount; /* specpdl_depth () when invoked */ 62 int pdlcount; /* specpdl_depth () when invoked */
63 char evalargs; 63 char evalargs;
64 /* Nonzero means call value of debugger when done with this operation. */ 64 /* Nonzero means call value of debugger when done with this operation. */
65 char debug_on_exit; 65 char debug_on_exit;
66
67 /* All the rest is information for the use of the profiler. The only
68 thing that eval.c does is set the first value to 0 so that it can
69 be relied upon. */
70
71 /* ----------------------------------------------------------------- */
72
73 /* 0 = profiling not turned on when function called.
74 Since profiling can be turned on and off dynamically, we can't
75 always count on having info recorded when a function was called
76 and need to take evasive action if necessary.
77 1 = profiling turned on but function not yet actually called. Lots of
78 stuff can happen between when a function is pushed onto the
79 backtrace list and when it's actually called (e.g. evalling its
80 arguments, autoloading, etc.). For greater accuracy we don't
81 treat the preamble stuff as part of the function itself.
82 2 = profiling turned on, function called.
83 */
84 char function_being_called;
85 /* The trick here is handling recursive functions and dealing with the
86 dynamicity of in-profile/not-in-profile. I used to just use a bunch
87 of hash tables for all info but that fails in the presence of
88 recursive functions because they can modify values out from under
89 you. The algorithm here is that we record the total_ticks and
90 total_consing, as well as the current values of `total-timing' and
91 `total-gc-usage' for the OBJ -- that's because recursive functions,
92 which get called later and exit early, will go ahead and modify the
93 `total-timing' and `total-gc-usage' for the fun, even though it's
94 not "correct" because the outer function is still running. However,
95 if we ask for profiling info at this point, at least we're getting
96 SOME info.
97
98 So ... On entry, we record these four values. On exit, we compute
99 an offset from the recorded value to the current value and then
100 store it into the appropriate hash table entry, using the recorded
101 value in the entry rather than the actual one. (Inner recursive
102 functions may have added their own values to the total-counts, and
103 we want to subsume them, not add to them.)
104
105 #### Also we need to go through the backtrace list during
106 stop-profiling and record values, just like for unwind_to. */
107 EMACS_INT current_total_timing_val;
108 EMACS_INT current_total_gc_usage_val;
109 EMACS_UINT total_ticks_at_start;
110 EMACS_UINT total_consing_at_start;
66 }; 111 };
67 112
68 /* This structure helps implement the `catch' and `throw' control 113 /* This structure helps implement the `catch' and `throw' control
69 structure. A struct catchtag contains all the information needed 114 structure. A struct catchtag contains all the information needed
70 to restore the state of the interpreter after a non-local jump. 115 to restore the state of the interpreter after a non-local jump.
347 FFU_symbol->value = FFU_newval; \ 392 FFU_symbol->value = FFU_newval; \
348 else \ 393 else \
349 Fset (FFU_sym, FFU_newval); \ 394 Fset (FFU_sym, FFU_newval); \
350 } while (0) 395 } while (0)
351 396
397 /* Note: you must always fill in all of the fields in a backtrace structure
398 before pushing them on the backtrace_list. The profiling code depends
399 on this. */
400
401 #define PUSH_BACKTRACE(bt) do { \
402 (bt).next = backtrace_list; \
403 backtrace_list = &(bt); \
404 } while (0)
405
406 #define POP_BACKTRACE(bt) do { \
407 backtrace_list = (bt).next; \
408 } while (0)
409
352 #endif /* INCLUDED_backtrace_h_ */ 410 #endif /* INCLUDED_backtrace_h_ */