From: Christophe Rhodes Date: Mon, 19 Jul 2010 07:02:48 +0000 (+0000) Subject: 1.0.40.5: comment changes X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=48f1b4dc1e7ee809bbeb92cf6595f1298450c136;p=sbcl.git 1.0.40.5: comment changes reflows and typo fixes --- diff --git a/src/pcl/cache.lisp b/src/pcl/cache.lisp index bb60a03..1165922 100644 --- a/src/pcl/cache.lisp +++ b/src/pcl/cache.lisp @@ -53,7 +53,7 @@ ;;;; ;;;; * 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. ;;;; @@ -336,8 +336,8 @@ (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 @@ -348,9 +348,9 @@ ;; 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 diff --git a/src/pcl/ctor.lisp b/src/pcl/ctor.lisp index 6f703ad..5c48952 100644 --- a/src/pcl/ctor.lisp +++ b/src/pcl/ctor.lisp @@ -348,9 +348,9 @@ (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 # ...) 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 # ...) 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)) @@ -402,9 +402,9 @@ (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 @@ -420,7 +420,8 @@ ,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))) @@ -428,9 +429,10 @@ (.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)))))))))) @@ -582,8 +584,9 @@ `(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 diff --git a/version.lisp-expr b/version.lisp-expr index 00ce366..d54095e 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -17,4 +17,4 @@ ;;; checkins which aren't released. (And occasionally for internal ;;; versions, especially for internal versions off the main CVS ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) -"1.0.40.4" +"1.0.40.5"