\f
;;;; utilities
-(eval-when (:compile-toplevel :load-toplevel :execute)
- (defconstant max-hash sb!xc:most-positive-fixnum))
-
;;; Code for detecting concurrent accesses to the same table from
;;; multiple threads. Only compiled in when the :SB-HASH-TABLE-DEBUG
;;; feature is enabled. The main reason for the existence of this code
;;; internal hash-table has been corrupted. It's plausible that this
;;; could be useful for some user code too, but the runtime cost is
;;; really too high to enable it by default.
-(defmacro with-concurrent-access-check (hash-table &body body)
- (declare (ignorable hash-table))
+(defmacro with-concurrent-access-check (hash-table operation &body body)
+ (declare (ignorable hash-table operation)
+ (type (member :read :write) operation))
#!-sb-hash-table-debug
`(progn ,@body)
#!+sb-hash-table-debug
- (once-only ((hash-table hash-table))
- `(progn
- (flet ((body-fun ()
- ,@body)
- (error-fun ()
- ;; Don't signal more errors for this table.
- (setf (hash-table-concurrent-access-error ,hash-table) nil)
- (error "Concurrent access to ~A" ,hash-table)))
- (if (hash-table-concurrent-access-error ,hash-table)
- (let ((thread (hash-table-accessing-thread ,hash-table)))
+ (let ((thread-slot-accessor (if (eq operation :read)
+ 'hash-table-reading-thread
+ 'hash-table-writing-thread)))
+ (once-only ((hash-table hash-table))
+ `(progn
+ (flet ((body-fun ()
+ ,@body)
+ (error-fun ()
+ ;; Don't signal more errors for this table.
+ (setf (hash-table-signal-concurrent-access ,hash-table) nil)
+ (cerror "Ignore the concurrent access"
+ "Concurrent access to ~A" ,hash-table)))
+ (declare (inline body-fun))
+ (if (hash-table-signal-concurrent-access ,hash-table)
(unwind-protect
(progn
- (when (and thread
- (not (eql thread sb!thread::*current-thread*)))
+ (unless (and (null (hash-table-writing-thread
+ ,hash-table))
+ ,@(when (eq operation :write)
+ `((null (hash-table-reading-thread
+ ,hash-table)))))
(error-fun))
- (setf (hash-table-accessing-thread ,hash-table)
+ (setf (,thread-slot-accessor ,hash-table)
sb!thread::*current-thread*)
(body-fun))
- (unless (eql (hash-table-accessing-thread ,hash-table)
- sb!thread::*current-thread*)
+ (unless (and ,@(when (eq operation :read)
+ `((null (hash-table-writing-thread
+ ,hash-table))))
+ ,@(when (eq operation :write)
+ ;; no readers are allowed while writing
+ `((null (hash-table-reading-thread
+ ,hash-table))
+ (eq (hash-table-writing-thread
+ ,hash-table)
+ sb!thread::*current-thread*))))
(error-fun))
- (setf (hash-table-accessing-thread ,hash-table) thread)))
- (body-fun))))))
-
-(deftype hash ()
- `(integer 0 ,max-hash))
-
-;;; FIXME: Does this always make a nonnegative FIXNUM? If so, then
-;;; explain why. If not (or if the reason it always makes a
-;;; nonnegative FIXNUM is only the accident that pointers in supported
-;;; architectures happen to be in the lower half of the address
-;;; space), then fix it.
-#!-sb-fluid (declaim (inline pointer-hash))
-(defun pointer-hash (key)
- (declare (values hash))
- (truly-the hash (%primitive sb!c:make-fixnum key)))
+ (when (eq (,thread-slot-accessor ,hash-table)
+ sb!thread::*current-thread*)
+ ;; this is not 100% correct here and may hide
+ ;; concurrent access in rare circumstances.
+ (setf (,thread-slot-accessor ,hash-table) nil)))
+ (body-fun)))))))
#!-sb-fluid (declaim (inline eq-hash))
(defun eq-hash (key)
(ash 1 (integer-length num)))
(declaim (inline index-for-hashing))
-(defun index-for-hashing (index length)
- (declare (type index index length))
+(defun index-for-hashing (hash length)
+ (declare (type hash hash length))
;; We're using power of two tables which obviously are very
;; sensitive to the exact values of the low bits in the hash
;; value. Do a little shuffling of the value to mix the high bits in
;; there too.
- (logand (1- length)
- (+ (logxor #b11100101010001011010100111
- index)
- (ash index -6)
- (ash index -15)
- (ash index -23))))
+ (truly-the index
+ (logand (1- length)
+ (+ (logxor #b11100101010001011010100111
+ hash)
+ (ash hash -3)
+ (ash hash -12)
+ (ash hash -20)))))
\f
;;;; user-defined hash table tests
(setf (hash-table-cache hash-table) index)))
(defmacro with-hash-table-locks ((hash-table
- &key inline pin
+ &key (operation :write) inline pin
(synchronized `(hash-table-synchronized-p ,hash-table)))
&body body)
+ (declare (type (member :read :write) operation))
(with-unique-names (body-fun)
- `(with-concurrent-access-check ,hash-table
+ `(with-concurrent-access-check ,hash-table ,operation
(flet ((,body-fun ()
(locally (declare (inline ,@inline))
,@body)))
(defun gethash3 (key hash-table default)
"Three argument version of GETHASH"
(declare (type hash-table hash-table))
- (with-hash-table-locks (hash-table :inline (%gethash3) :pin (key))
+ (with-hash-table-locks (hash-table :operation :read :inline (%gethash3)
+ :pin (key))
(%gethash3 key hash-table default)))
;;; so people can call #'(SETF GETHASH)
(aver (hash-table-index-vector hash-table))
(macrolet ((put-it (lockedp)
`(let ((cache (hash-table-cache hash-table))
- (kv-vector (hash-table-table hash-table)))
- ;; Check the cache
- (if (and cache
- (< cache (length kv-vector))
- (eq (aref kv-vector cache) key))
- ;; If cached, just store here
- (setf (aref kv-vector (1+ cache)) value)
- ;; Otherwise do things the hard way
+ (kv-vector (hash-table-table hash-table)))
+ ;; Check the cache
+ (if (and cache
+ (< cache (length kv-vector))
+ (eq (aref kv-vector cache) key))
+ ;; If cached, just store here
+ (setf (aref kv-vector (1+ cache)) value)
+ ;; Otherwise do things the hard way
,(if lockedp
'(%%puthash key hash-table value)
'(with-hash-table-locks
(when hash-vector
(setf (aref hash-vector slot-location)
+magic-hash-vector-value+))
+ ;; On parallel accesses this may turn out to be a
+ ;; type-error, so don't turn down the safety!
(decf (hash-table-number-entries hash-table))
t))
(cond ((zerop next)
(cond ((or (not *print-readably*) (not *read-eval*))
(print-unreadable-object (hash-table stream :type t :identity t)
(format stream
- ":TEST ~S :COUNT ~S"
+ ":TEST ~S :COUNT ~S~@[ :WEAKNESS ~S~]"
(hash-table-test hash-table)
- (hash-table-count hash-table))))
+ (hash-table-count hash-table)
+ (hash-table-weakness hash-table))))
(t
- (with-standard-io-syntax
- (format stream
- "#.~W"
- `(%stuff-hash-table (make-hash-table ,@(%hash-table-ctor-args
+ (write-string "#." stream)
+ (write `(%stuff-hash-table (make-hash-table ,@(%hash-table-ctor-args
hash-table))
- ',(%hash-table-alist hash-table)))))))
+ ',(%hash-table-alist hash-table))
+ :stream stream))))
(def!method make-load-form ((hash-table hash-table) &optional environment)
(declare (ignore environment))
projects / sbcl.git / blobdiff