[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#18180: 24.3.92; Segfault in mark_object

From: Mat Smiglarski
Subject: bug#18180: 24.3.92; Segfault in mark_object
Date: Mon, 04 Aug 2014 07:46:32 +0100
User-agent: Roundcube Webmail/1.0.1

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 ()
  (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


"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)
  "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)
          (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)))
     (setq buffer-read-only t)
     (use-local-map stress-map)
     (set-frame-font (font-spec :size 50))))

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

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

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

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

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

(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."
  (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."
(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)))
           (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)

(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))

(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.


reply via email to

[Prev in Thread] Current Thread [Next in Thread]