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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
;;;; Copyright (C) 2008 Free Software Foundation, Inc.
;;;;
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 2.1 of the License, or (at your option) any later version.
;;;;
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;;; Lesser General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;;;;
;;; Commentary:
;;; This code is run during the Guile build, in order to set the stack
;;; limit to a value that will allow the `make check' tests to pass,
;;; taking into account the average stack usage on the build platform.
;;; For more detail, see the text below that gets written out to the
;;; stack limit calibration file.
;;; Code:
;; Store off Guile's default stack limit.
(define default-stack-limit (cadr (memq 'stack (debug-options))))
;; Now disable the stack limit, so that we don't get a stack overflow
;; while running this code!
(debug-set! stack 0)
;; Define a variable to hold the measured stack high water mark (HWM).
(define top-repl-hwm-measured 0)
;; Use an evaluator trap to measure the stack size at every
;; evaluation step, and increase top-repl-hwm-measured if it is less
;; than the measured stack size.
(trap-set! enter-frame-handler
(lambda _
(let ((stack-size (%get-stack-size)))
(if (< top-repl-hwm-measured stack-size)
(set! top-repl-hwm-measured stack-size)))))
(trap-enable 'enter-frame)
(trap-enable 'traps)
;; Call (turn-on-debugging) and (top-repl) in order to simulate as
;; closely as possible what happens - and in particular, how much
;; stack is used - when a standard Guile REPL is started up.
;;
;; `make check' stack overflow errors have been reported in the past
;; for:
;;
;; - test-suite/standalone/test-use-srfi, which runs `guile -q
;; --use-srfi=...' a few times, with standard input for the REPL
;; coming from a shell script
;;
;; - test-suite/tests/elisp.test, which does not involve the REPL, but
;; has a lot of `use-modules' calls.
;;
;; Stack high water mark (HWM) measurements show that the HWM is
;; higher in the test-use-srfi case - specifically because of the
;; complexity of (top-repl) - so that is what we simulate for our
;; calibration model here.
(turn-on-debugging)
(with-output-to-port (%make-void-port "w")
(lambda ()
(with-input-from-string "\n" top-repl)))
;; top-repl-hwm-measured now contains the stack HWM that resulted from
;; running that code.
;; This is the value of top-repl-hwm-measured that we get on a
;; `canonical' build platform. (See text below for what that means.)
(define top-repl-hwm-i686-pc-linux-gnu 9461)
;; Using the above results, output code that tests can run in order to
;; configure the stack limit correctly for the current build platform.
(format #t "\
;; Stack limit calibration file.
;;
;; This file is automatically generated by Guile when it builds, in
;; order to set the stack limit to a value that reflects the stack
;; usage of the build platform (OS + compiler + compilation options),
;; specifically so that none of Guile's own tests (which are run by
;; `make check') fail because of a benign stack overflow condition.
;;
;; By a `benign' stack overflow condition, we mean one where the test
;; code is behaving correctly, but exceeds the configured stack limit
;; because the limit is set too low. A non-benign stack overflow
;; condition would be if a piece of test code behaved significantly
;; differently on some platform to how it does normally, and as a
;; result consumed a lot more stack. Although they seem pretty
;; unlikely, we would want to catch non-benign conditions like this,
;; and that is why we don't just do `(debug-set! stack 0)' when
;; running `make check'.
;;
;; Although the primary purpose of this file is to prevent `make
;; check' from failing without good reason, Guile developers and users
;; may also find the following information useful, when determining
;; what stack limit to configure for their own programs.
(let (;; The stack high water mark measured when starting up the
;; standard Guile REPL on the current build platform.
(top-repl-hwm-measured ~a)
;; The value of top-repl-hwm-measured that we get when building
;; Guile on an i686 PC GNU/Linux system, after configuring with
;; `./configure --enable-maintainer-mode --with-threads'.
;; (Hereafter referred to as the `canonical' build platform.)
(top-repl-hwm-i686-pc-linux-gnu ~a)
;; Guile's default stack limit (i.e. the initial, C-coded value
;; of the 'stack debug option). In the context of this file,
;; the important thing about this number is that we know that
;; it allows all of the `make check' tests to pass on the
;; canonical build platform.
(default-stack-limit ~a)
;; Calibrated stack limit. This is the default stack limit,
;; scaled by the factor between top-repl-hwm-i686-pc-linux-gnu
;; and top-repl-hwm-measured.
(calibrated-stack-limit ~a))
;; Configure the calibrated stack limit.
(debug-set! stack calibrated-stack-limit))
"
top-repl-hwm-measured
top-repl-hwm-i686-pc-linux-gnu
default-stack-limit
;; Use quotient here to get an integer result, rather than a
;; rational.
(quotient (* default-stack-limit top-repl-hwm-measured)
top-repl-hwm-i686-pc-linux-gnu))
|