0.8.13.7:

	Just for fun: implement the Intel prefetch instructions, and
	conditionally use (one of) them in typetag checking
	... no, it doesn't make anything noticeably faster; why do you
		ask?

diff --git a/src/compiler/x86/insts.lisp b/src/compiler/x86/insts.lisp
index ebfa2b8..8117383 100644 (file)
--- a/src/compiler/x86/insts.lisp
+++ b/src/compiler/x86/insts.lisp
@@ -615,6 +615,14 @@
   (disp :field (byte 16 8))
   (level :field (byte 8 24)))
 
+(sb!disassem:define-instruction-format (prefetch 24
+                                                :default-printer
+                                                '(:name ", " reg/mem))
+  (prefix :field (byte 8 0) :value #b00001111)
+  (op :field (byte 8 8) :value #b00011000)
+  (reg/mem :fields (list (byte 2 22) (byte 3 16)) :type 'byte-reg/mem)
+  (reg :field (byte 3 19) :type 'reg))
+
 ;;; Single byte instruction with an immediate byte argument.
 (sb!disassem:define-instruction-format (byte-imm 16
                                     :default-printer '(:name :tab code))
@@ -1840,6 +1848,43 @@
   (:emitter
    (emit-byte segment #b11001001)))
 \f
+;;;; prefetch
+(define-instruction prefetchnta (segment ea)
+  (:printer prefetch ((op #b00011000) (reg #b000)))
+  (:emitter
+   (aver (typep ea 'ea))
+   (aver (eq :byte (ea-size ea)))
+   (emit-byte segment #b00001111)
+   (emit-byte segment #b00011000)
+   (emit-ea segment ea #b000)))
+
+(define-instruction prefetcht0 (segment ea)
+  (:printer prefetch ((op #b00011000) (reg #b001)))
+  (:emitter
+   (aver (typep ea 'ea))
+   (aver (eq :byte (ea-size ea)))
+   (emit-byte segment #b00001111)
+   (emit-byte segment #b00011000)
+   (emit-ea segment ea #b001)))
+
+(define-instruction prefetcht1 (segment ea)
+  (:printer prefetch ((op #b00011000) (reg #b010)))
+  (:emitter
+   (aver (typep ea 'ea))
+   (aver (eq :byte (ea-size ea)))
+   (emit-byte segment #b00001111)
+   (emit-byte segment #b00011000)
+   (emit-ea segment ea #b010)))
+
+(define-instruction prefetcht2 (segment ea)
+  (:printer prefetch ((op #b00011000) (reg #b011)))
+  (:emitter
+   (aver (typep ea 'ea))
+   (aver (eq :byte (ea-size ea)))
+   (emit-byte segment #b00001111)
+   (emit-byte segment #b00011000)
+   (emit-ea segment ea #b011)))
+\f
 ;;;; interrupt instructions
 
 (defun snarf-error-junk (sap offset &optional length-only)

diff --git a/src/compiler/x86/type-vops.lisp b/src/compiler/x86/type-vops.lisp
index 7335973..fda5f13 100644 (file)
--- a/src/compiler/x86/type-vops.lisp
+++ b/src/compiler/x86/type-vops.lisp
@@ -62,6 +62,14 @@
   (unless al-loaded
     (move eax-tn value)
     (inst and al-tn lowtag-mask))
+  ;; FIXME: another 'optimization' which doesn't appear to work:
+  ;; prefetching the hypothetically pointed-to version should help,
+  ;; but this is in fact non-ideal in plenty of ways: we emit way too
+  ;; many of these prefetch instructions; pointed-to objects are very
+  ;; often in the cache anyway; etc. etc.  Still, as proof-of-concept,
+  ;; not too bad.  -- CSR, 2004-07-27
+  (when (member :prefetch *backend-subfeatures*)
+    (inst prefetchnta (make-ea :byte :base value :disp (- lowtag))))
   (inst cmp al-tn lowtag)
   (inst jmp (if not-p :ne :e) target))
   

diff --git a/version.lisp-expr b/version.lisp-expr
index 03dc130..cac3b19 100644 (file)
--- 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".)
-"0.8.13.6"
+"0.8.13.7"