Custom Query (1030 matches)

I was surprised that ccl:save-application called ccl:*lisp-cleanup-functions* before saving the image. I expected a snapshot of the current image (this is the behavior of other implementations), not an image in a post-shutdown state.

I can use ccl:*save-exit-functions* to save the desired state, or restore state with ccl:*lisp-startup-functions*, but neither may be easy in general.

If it is decided that the current behavior is preferred, then at least document it in ccl:save-application or elsewhere, as it differs from other implementations.

The currently last COND clause in ACODE-OPTIMIZE-ASH tries to inline some calls to ASH based on information about the arguments' types; it erroneously assumes that if the types are subtypes of FIXNUM, they must be represented as NUMERIC-CTYPEs in CCL. Types specified as (e.g.) (MEMBER 23 5) are subtypes of FIXNUM that aren't represented as NUMERIC-CTYPEs.

This clause in ACODE-OPTIMIZE-ASH shouldn't make this assumption.

see ​http://clozure.com/pipermail/openmcl-devel/2012-November/013919.html

(This is assuming ccl::conditional-store should work as a typical compare-and-swap, even though it's not exported.)

The RUN function below causes an assertion failure within 2000 iterations on my Linux-x86 machine. An svref place has the same issue. I did not see a problem on Darwin.

Removing the assertion (but keeping the conditional-store) results in a hang. Replacing that conditional-store (the second one) with setf also produces a hang.

(defstruct stack
  (head nil)
  (lock nil))

(defun call-with-spin-lock (stack fn)
  (loop :until (ccl::conditional-store
                (stack-lock stack) nil t))
  (unwind-protect
       (funcall fn)
    (assert (ccl::conditional-store
             (stack-lock stack) t nil))))

(defmacro with-spin-lock ((stack) &body body)
  `(call-with-spin-lock ,stack (lambda () ,@body)))

(defun push-stack (value stack)
  (with-spin-lock (stack)
    (push value (stack-head stack))))

(defun pop-stack (stack)
  (with-spin-lock (stack)
    (pop (stack-head stack))))

(defun test (thread-count)
  (let ((stack (make-stack)))
    (loop :repeat thread-count
          :do (ccl:process-run-function "test" #'push-stack t stack))
    (loop :repeat thread-count
          :do (loop :until (pop-stack stack)))))

(defun run ()
  (loop
     (test 1)
     (format t ".")))