X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-sxhash.lisp;h=953160b33049dc57da29ea689aa229c18f79e35c;hb=2c9e9cdf20257c422cd43bd30b89990499bca475;hp=dbe9d23de5549e818ba013102813c697b8479be3;hpb=5a9b7fcee7cd5374010d7a5b05463b84abc35079;p=sbcl.git diff --git a/src/code/target-sxhash.lisp b/src/code/target-sxhash.lisp index dbe9d23..953160b 100644 --- a/src/code/target-sxhash.lisp +++ b/src/code/target-sxhash.lisp @@ -11,6 +11,9 @@ (in-package "SB!IMPL") +(defun pointer-hash (key) + (pointer-hash key)) + ;;; the depthoid explored when calculating hash values ;;; ;;; "Depthoid" here is a sort of mixture of what Common Lisp ordinarily calls @@ -40,6 +43,7 @@ (and fixnum unsigned-byte)) (and fixnum unsigned-byte)) mix)) +(declaim (inline mix)) (defun mix (x y) ;; FIXME: We wouldn't need the nasty (SAFETY 0) here if the compiler ;; were smarter about optimizing ASH. (Without the THE FIXNUM below, @@ -79,7 +83,7 @@ ;;;; for some more ;;;; information). -#!-sb-fluid (declaim (inline %sxhash-substring)) +(declaim (inline %sxhash-substring)) (defun %sxhash-substring (string &optional (count (length string))) ;; FIXME: As in MIX above, we wouldn't need (SAFETY 0) here if the ;; cross-compiler were smarter about ASH, but we need it for @@ -138,24 +142,8 @@ ;;;; the SXHASH function ;; simple cases -(declaim (ftype (sfunction (integer) (integer 0 #.sb!xc:most-positive-fixnum)) - sxhash-bignum)) -(declaim (ftype (sfunction (t) (integer 0 #.sb!xc:most-positive-fixnum)) - sxhash-instance)) - -(defmacro hash-array-using (recurse array depthoid) - ;; Any other array can be hashed by working with its underlying - ;; one-dimensional physical representation. Used by both SXHASH and - ;; PSXHASH. - (once-only ((array array) (depthoid depthoid)) - `(let ((result 60828123)) - (declare (type fixnum result)) - (dotimes (i (min ,depthoid (array-rank ,array))) - (mixf result (array-dimension ,array i))) - (dotimes (i (min ,depthoid (array-total-size ,array))) - (mixf result - (,recurse (row-major-aref ,array i) (- ,depthoid 1 i)))) - result))) +(declaim (ftype (sfunction (integer) hash) sxhash-bignum)) +(declaim (ftype (sfunction (t) hash) sxhash-instance)) (defun sxhash (x) ;; profiling SXHASH is hard, but we might as well try to make it go @@ -195,12 +183,27 @@ (sxhash-recurse (cdr x) (1- depthoid))) 261835505))) (instance - (if (or (typep x 'structure-object) (typep x 'condition)) - (logxor 422371266 - (sxhash ; through DEFTRANSFORM - (classoid-name - (layout-classoid (%instance-layout x))))) - (sxhash-instance x))) + (if (pathnamep x) + ;; Pathnames are EQUAL if all the components are EQUAL, so + ;; we hash all of the components of a pathname together. + (let ((hash (sxhash-recurse (pathname-host x) depthoid))) + (mixf hash (sxhash-recurse (pathname-device x) depthoid)) + (mixf hash (sxhash-recurse (pathname-directory x) depthoid)) + (mixf hash (sxhash-recurse (pathname-name x) depthoid)) + (mixf hash (sxhash-recurse (pathname-type x) depthoid)) + ;; Hash :NEWEST the same as NIL because EQUAL for + ;; pathnames assumes that :newest and nil are equal. + (let ((version (%pathname-version x))) + (mixf hash (sxhash-recurse (if (eq version :newest) + nil + version) + depthoid)))) + (if (or (typep x 'structure-object) (typep x 'condition)) + (logxor 422371266 + (sxhash ; through DEFTRANSFORM + (classoid-name + (layout-classoid (%instance-layout x))))) + (sxhash-instance x)))) (symbol (sxhash x)) ; through DEFTRANSFORM (array (typecase x @@ -212,11 +215,10 @@ ;; than this. The problem is that a non-SIMPLE ;; BIT-VECTOR could be displaced to another, with a ;; non-zero offset -- so that significantly more - ;; work needs to be done using the %RAW-BITS + ;; work needs to be done using the %VECTOR-RAW-BITS ;; approach. This will probably do for now. (sxhash-recurse (copy-seq x) depthoid)) - (t - (hash-array-using sxhash-recurse x depthoid)))) + (t (logxor 191020317 (sxhash (array-rank x)))))) (character (logxor 72185131 (sxhash (char-code x)))) ; through DEFTRANSFORM @@ -249,7 +251,7 @@ (structure-object (structure-object-psxhash key depthoid)) (cons (list-psxhash key depthoid)) (number (number-psxhash key)) - (character (sxhash (char-upcase key))) + (character (char-code (char-upcase key))) (t (sxhash key)))) (defun array-psxhash (key depthoid) @@ -264,25 +266,37 @@ '(let ((result 572539)) (declare (type fixnum result)) (mixf result (length key)) - (dotimes (i (min depthoid (length key))) + (when (plusp depthoid) + (decf depthoid) + (dotimes (i (length key)) (declare (type fixnum i)) (mixf result - (psxhash (aref key i) - (- depthoid 1 i)))) - result))) - ;; CMU can compile SIMPLE-ARRAY operations so much more efficiently - ;; than the general case that it's probably worth picking off the - ;; common special cases. - (typecase key - (simple-string - ;;(format t "~&SIMPLE-STRING special case~%") - (frob)) - (simple-vector - ;;(format t "~&SIMPLE-VECTOR special case~%") - (frob)) - (t (frob))))) + (psxhash (aref key i) depthoid)))) + result)) + (make-dispatch (types) + `(typecase key + ,@(loop for type in types + collect `(,type + (frob)))))) + (make-dispatch (simple-base-string + (simple-array character (*)) + simple-vector + (simple-array (unsigned-byte 8) (*)) + (simple-array fixnum (*)) + t)))) + ;; Any other array can be hashed by working with its underlying + ;; one-dimensional physical representation. (t - (hash-array-using psxhash key depthoid)))) + (let ((result 60828)) + (declare (type fixnum result)) + (dotimes (i (array-rank key)) + (mixf result (array-dimension key i))) + (when (plusp depthoid) + (decf depthoid) + (dotimes (i (array-total-size key)) + (mixf result + (psxhash (row-major-aref key i) depthoid)))) + result)))) (defun structure-object-psxhash (key depthoid) (declare (optimize speed)) @@ -339,8 +353,8 @@ (etypecase key (integer (sxhash key)) (float (macrolet ((frob (type) - (let ((lo (coerce most-negative-fixnum type)) - (hi (coerce most-positive-fixnum type))) + (let ((lo (coerce sb!xc:most-negative-fixnum type)) + (hi (coerce sb!xc:most-positive-fixnum type))) `(cond (;; This clause allows FIXNUM-sized integer ;; values to be handled without consing. (<= ,lo key ,hi)