bug#18180: 24.3.92; Segfault in mark_object

[Mat Smiglarski]

On 2014-08-04 05:22, Dmitry Antipov wrote:
> On 08/03/2014 07:03 PM, Mat Smiglarski wrote:
>
> > 2. Call some code which kills and creates a frame between 2 and 25 
> > times.
>
> This doesn't look specific and useful. Do you create frame(s) with
> some non-default parameters?  After making changes in frame-related
> code, I usually do something like this:
>
> (defun frame-test ()
>   (interactive)
>   (dotimes (i 10)
>     (let ((frame-list nil))
>       (dotimes (j 10)
> (setq frame-list (cons (make-frame) frame-list)))
>       (mapcar #'delete-frame frame-list))))
>
> Can you reproduce your crash with this?

No that works fine.

On 2014-08-04 05:39, Dmitry Antipov wrote:
> On 08/03/2014 07:03 PM, Mat Smiglarski wrote:
>
> > $ emacs -Q
>
> [...skip...]
>
> > "stupider-speed-read" (0xffffd6c8)
>
> What's this?  This doesn't look like a feature comes from
> standard Lisp code.  I'm just curious how you get into
> this by running with -Q...

That is the code being used as a stress test; the code that I call 
between 2 and 25 times.

Perhaps you need to see the code, which has been slightly renamed. It 
can be made shorter by removing the comments and some key mappings but 
that doesn't seem very helpful.

1. Create stress-test.el with the following

(require 'cl)

(defvar stress-buffer-name "stress" "The name of the buffer created by 
`stress'.")
(defvar pause-time 0.1)

(defvar stress-map
  (let ((km (make-sparse-keymap)))
    (define-key km (kbd "q") 'stress-quit)
    (define-key km (kbd "SPC") 'stress-toggle-pause)
    (define-key km (kbd "n") 'stress-tick)
    km)
  "Keymap for `stress-speed-read'.")

(defun stress-speed-read (source-buffer)
  "Create and run a speed reading frame for `SOURCE-BUFFER'.
Words from BUFFER are displayed individually and progressed by an 
adjustable timer."
  (interactive "bCreate stress-speed-reader for source buffer: ")
  (stress-quit) ; Ensure that it is starting from a clean state.
  (setq min-pause-time 0.1)
  (setq tokeniser "[^ \n]+")
  (setq *source-buffer* (make-indirect-buffer source-buffer "source 
buffer"))
  (setq stress-frame
        (let* ((width 200)
               (left (- (/ (- (x-display-pixel-width) ; center frame
                              width) 2)
                        8)))
          (make-frame `((height . 1)
                        (left . ,left)
                        (top . 100)
                        (mode-line-format . nil)
                        (cursor-type . nil)
                        (minibuffer . nil)
                        (left-margin . 0)
                        (left-fringe . 0)
                        (right-fringe . 0)
                        (tool-bar-lines . 0)
                        (menu-bar-lines . 0)
                        (line-spacing . 0)
                        (unsplittable . t)
                        (fill-column . 30)))))
  (setq stress-buffer (get-buffer-create stress-buffer-name))
  (with-current-buffer *source-buffer*
    (goto-char (point-min))
    (with-selected-frame stress-frame
      (display-buffer stress-buffer '((display-buffer-same-window)))
    (stress--do
     (fundamental-mode)
     (setq buffer-read-only t)
     (use-local-map stress-map)
     (set-frame-font (font-spec :size 50))))
  (stress--start)))

(defmacro stress--do (&rest body)
  "Do something in the speed reading frame."
  `(with-selected-frame stress-frame
     (with-current-buffer stress-buffer
       ,@body)))

(defun stress-running-p ()
  "Is the speed reader running."
  (and (get-buffer stress-buffer-name) t))

(defun stress-toggle-pause ()
  "Pause or unpause."
  (interactive)
  (if (timerp resume-timer)
      (stress--stop)
    (stress--start)))

(defun stress--start ()
  "Start, and then continue on a timer."
  (stress-tick)
  (stress--resume pause-time))

(defun stress--resume (delay)
  "Iterate after a delay of `DELAY' seconds."
  (if (> delay 0)
      (setq resume-timer
            (run-at-time
             (format "%2f seconds" delay)
             nil #'stress-tick))
    (stress-quit)))

(defun stress--stop ()
  "Stop. Well more of a pause than a stop, really."
  (when (and (boundp 'resume-timer) (timerp resume-timer))
    (cancel-timer resume-timer)
    (setq resume-timer nil)))

(defun stress-quit ()
  "Quit the speed reader."
  (interactive)
  (stress--stop)
  (when (and (boundp 'stress-buffer)
             (buffer-live-p stress-buffer))
    (kill-buffer stress-buffer)
    (setq stress-buffer nil))
  (when (buffer-live-p (get-buffer "source buffer"))
    (kill-buffer "source buffer")
    (setq *source-buffer* nil))
  (when (and (boundp 'stress-frame)
             (frame-live-p stress-frame))
    (delete-frame stress-frame)
    (setq stress-frame nil)))

(defun stress-tick ()
  "Progress the reading.
This function handles being called either during manual or automatic 
iteration,
whether paused or not."
  (interactive)
  (let ((was-running-p (and (boundp 'resume-timer) (timerp 
resume-timer)))
        (s (with-current-buffer *source-buffer*
             (and (search-forward-regexp tokeniser nil t)
                  (match-string-no-properties 0)))))
    (stress--stop) ; ensure stopped
    (if s
        (let ((center (max (/ (length s) 2) 1)))
          (stress--do
           (setq buffer-read-only nil)
           (put-text-property 0 (length s) 'face '(foreground-color . 
"DeepSkyBlue") s)
           (put-text-property (- center 1) center 'face 
'(foreground-color . "tomato") s)
           (goto-char (point-min))
           (loop repeat
                 (max (- (/ 30 2) center) 0)
                 do (insert " "))
           (insert s)
           (delete-region (point) (point-max))
           (setq buffer-read-only t)
           (when was-running-p
             (stress--resume (* (stress--punctuation-weighting s)
                                  pause-time)))))
      (stress-quit))))

(defun stress--punctuation-weighting (str)
  "Returns the punctuation delay modifier for `STR', where 0 is a 
request to stop."
  (if str
      (case (last (car (last (string-to-list str))))
        (?, 1.4)
        (?\; 1.6)
        (?. 2)
        (?\: 2.2)
        (t 1))
    0))

(defun stress--log ()
  "User feedback."
  (message (format "Pause-time: %.2f" pause-time)))

2. Start emacs

$ emacs -Q -l stress-test.el

3. Setup a macro

C-x ( M-x stress-speed-read RET C-x )

4. Delete and restart the frame and time 20 times, although 4 or 5 times 
is usually enough on this laptop.
Note that q is bound in the code above.

q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e 
q C-x e
q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e q C-x e 
q C-x e

5. See it crash.

Program received signal SIGSEGV, Segmentation fault.
0x00000000005b9d1a in mark_object (arg=140737253503599) at alloc.c:6318
6318          FLOAT_MARK (XFLOAT (obj));

I have not been able to reproduce this by automating the calls to 
stress-speed-read.
Increasing stress-pause-time makes the crash more difficult to 
reproduce.
Isolating the make-frame call, and running that 20 times does not cause 
the crash.

Regards,
Mat