;;;;
;;;; * Since the cache is used for memoization only we don't need to
;;;; worry about which of simultaneous replacements (when expanding
-;;;; the cache) takes place: the loosing one will have its work
+;;;; the cache) takes place: the losing one will have its work
;;;; redone later. This also allows us to drop entries when the
;;;; cache is about to grow insanely huge.
;;;;
(cache-mask copy) (compute-cache-mask length (cache-line-size cache))
(cache-limit copy) (compute-limit (/ length (cache-line-size cache))))
;; First insert the new one -- if we don't do this first and
- ;; the cache has reached it's maximum size we may end up
- ;; looping in FILL-CACHE.
+ ;; the cache has reached its maximum size we may end up looping
+ ;; in FILL-CACHE.
(unless (try-update-cache copy layouts value)
(bug "Could not insert ~S:~S to supposedly empty ~S." layouts value copy))
(map-cache (if drop-random-entries
;; rut: add A causing B to drop, then add B
;; causing A to drop... repeat ad nauseam,
;; spending most of the time here instead of
- ;; doing real work. 50% because if we drop to
+ ;; doing real work. 50% because if we drop too
;; few we need to do this almost right away
- ;; again, and if we drop to many, we need to
+ ;; again, and if we drop too many, we need to
;; recompute more then we'd like.
;; _Experimentally_ 50% seems to perform the
;; best, but it would be nice to have a proper
(define-compiler-macro make-instance (&whole form &rest args &environment env)
(declare (ignore args))
- ;; Compiling an optimized constructor for a non-standard class means compiling a
- ;; lambda with (MAKE-INSTANCE #<SOME-CLASS X> ...) in it -- need
- ;; to make sure we don't recurse there.
+ ;; Compiling an optimized constructor for a non-standard class means
+ ;; compiling a lambda with (MAKE-INSTANCE #<SOME-CLASS X> ...) in it
+ ;; -- need to make sure we don't recurse there.
(or (unless *compiling-optimized-constructor*
(make-instance->constructor-call form (safe-code-p env)))
form))
(setf (info :function :where-from function-name) :defined)
(when (info :function :assumed-type function-name)
(setf (info :function :assumed-type function-name) nil)))
- ;; Return code constructing a ctor at load time, which, when
- ;; called, will set its funcallable instance function to an
- ;; optimized constructor function.
+ ;; Return code constructing a ctor at load time, which,
+ ;; when called, will set its funcallable instance
+ ;; function to an optimized constructor function.
`(locally
(declare (disable-package-locks ,function-name))
(let ((.x. (load-time-value
,function-name))
(funcall (function ,function-name) ,@value-forms))))
(when (and class-arg (not (constantp class-arg)))
- ;; Build an inline cache: a CONS, with the actual cache in the CDR.
+ ;; Build an inline cache: a CONS, with the actual cache
+ ;; in the CDR.
`(locally (declare (disable-package-locks .cache. .class-arg. .store. .fun.
make-instance))
(let* ((.cache. (load-time-value (cons 'ctor-cache nil)))
(.class-arg. ,class-arg))
(multiple-value-bind (.fun. .new-store.)
(ensure-cached-ctor .class-arg. .store. ',initargs ',safe-code-p)
- ;; Thread safe: if multiple threads hit this in paralle, the update
- ;; from the other one is just lost -- no harm done, except for the
- ;; need to redo the work next time.
+ ;; Thread safe: if multiple threads hit this in
+ ;; parallel, the update from the other one is
+ ;; just lost -- no harm done, except for the need
+ ;; to redo the work next time.
(unless (eq .store. .new-store.)
(setf (cdr .cache.) .new-store.))
(funcall (truly-the function .fun.) ,@value-forms))))))))))
`(lambda ,lambda-list
(declare #.*optimize-speed*)
;; The CTOR MAKE-INSTANCE optimization checks for
- ;; *COMPILING-OPTIMIZED-CONSTRUCTOR* which is bound around compilation of
- ;; the constructor, hence avoiding the possibility of endless recursion.
+ ;; *COMPILING-OPTIMIZED-CONSTRUCTOR* which is bound around
+ ;; compilation of the constructor, hence avoiding the
+ ;; possibility of endless recursion.
(make-instance ,class ,@initargs))
(let ((defaults (class-default-initargs class)))
(when defaults
projects / sbcl.git / commitdiff