2:32 p.m.
changeset: 5266:f9ec07abdbf9
tag: tip
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Thu Sep 16 14:31:40 2010 +0100
files: lisp/ChangeLog lisp/cl-macs.el lisp/mule/mule-cmds.el
description:
Transform safe calls to (= X Y Z) to (and (= X Y) (= Y Z)); same for < > <=
>=
lisp/ChangeLog addition:
2010-09-16 Aidan Kehoe <kehoea(a)parhasard.net>
* cl-macs.el (= < > <= >=):
When these functions are handed more than two arguments, and those
arguments have no side effects, transform to a series of two
argument calls, avoiding funcall in the byte-compiled code.
* mule/mule-cmds.el (finish-set-language-environment):
Take advantage of this change in a function called 256 times at
startup.
diff -r 5663ae9a8989 -r f9ec07abdbf9 lisp/ChangeLog
--- a/lisp/ChangeLog Thu Sep 16 14:10:44 2010 +0100
+++ b/lisp/ChangeLog Thu Sep 16 14:31:40 2010 +0100
＠＠ -1,3 +1,13 ＠＠
+2010-09-16 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * cl-macs.el (= < > <= >=):
+ When these functions are handed more than two arguments, and those
+ arguments have no side effects, transform to a series of two
+ argument calls, avoiding funcall in the byte-compiled code.
+ * mule/mule-cmds.el (finish-set-language-environment):
+ Take advantage of this change in a function called 256 times at
+ startup.
+
2010-09-16 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp.el (byte-compile-function-form, byte-compile-quote)
diff -r 5663ae9a8989 -r f9ec07abdbf9 lisp/cl-macs.el
--- a/lisp/cl-macs.el Thu Sep 16 14:10:44 2010 +0100
+++ b/lisp/cl-macs.el Thu Sep 16 14:31:40 2010 +0100
＠＠ -3773,6 +3773,25 ＠＠
(string (cons 'concat (cddr form))))
form))
+(map nil
+ #'(lambda (function)
+ ;; There are byte codes for the two-argument versions of these
+ ;; functions; if the form has more arguments and those arguments
+ ;; have no side effects, transform to a series of two-argument
+ ;; calls.
+ (put function 'cl-compiler-macro
+ #'(lambda (form &rest arguments)
+ (if (or (null (nthcdr 3 form))
+ (notevery #'cl-safe-expr-p (cdr form)))
+ form
+ (cons 'and (mapcon
+ #'(lambda (rest)
+ (and (cdr rest)
+ `((,(car form) ,(pop rest)
+ ,(car rest)))))
+ (cdr form)))))))
+ '(= < > <= >=))
+
(mapc
#'(lambda (y)
(put (car y) 'side-effect-free t)
diff -r 5663ae9a8989 -r f9ec07abdbf9 lisp/mule/mule-cmds.el
--- a/lisp/mule/mule-cmds.el Thu Sep 16 14:10:44 2010 +0100
+++ b/lisp/mule/mule-cmds.el Thu Sep 16 14:31:40 2010 +0100
＠＠ -789,8 +789,7 ＠＠
(setq string (format "%c" unicode-error-lookup)))
;; Treat control characters specially:
(setq first-char (aref string 0))
- (when (or (and (>= first-char #x00) (<= first-char #x1f))
- (and (>= first-char #x80) (<= first-char #x9f)))
+ (when (or (<= #x00 first-char #x1f) (<= #x80 first-char #x9f))
(setq string (format "^%c" (+ ?＠ (aref string 0))))))
(setq glyph (make-glyph (vector 'string :data string)))
(set-glyph-face glyph 'unicode-invalid-sequence-warning-face)
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://calypso.tux.org/mailman/listinfo/xemacs-patches
6:48 a.m.
New subject: [Q] Transform safe calls to (= X Y Z) to (and (= X Y) (= Y Z)); same for < > <= >=
QUERY
Aidan Kehoe writes:
* cl-macs.el (= < > <= >=): When these functions are
handed
more than two arguments, and those arguments have no side effects,
transform to a series of two argument calls, avoiding funcall in
the byte-compiled code.
Shouldn't this be limited to some number of arguments? At some point
the byte interpreter overhead (vs the C implementation of these
functions) is going to outweigh funcall overhead. Or is there another
reason to avoid funcall besides overhead?
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://calypso.tux.org/mailman/listinfo/xemacs-patches
5:39 p.m.
New subject: [Q] Transform safe calls to (= X Y Z) to (and (= X Y) (= Y Z)); same for < > <= >=
Ar an seachtú lá déag de mí Méan Fómhair, scríobh Stephen J. Turnbull:
QUERY
Aidan Kehoe writes:
> * cl-macs.el (= < > <= >=): When these functions are handed
> more than two arguments, and those arguments have no side effects,
> transform to a series of two argument calls, avoiding funcall in
> the byte-compiled code.
Shouldn't this be limited to some number of arguments? At some point
the byte interpreter overhead (vs the C implementation of these
functions) is going to outweigh funcall overhead.
The byte interpreter overhead is three extra byte codes per iteration.
Here’s the funcall version of (<= a b 200):
byte code:
args: nil
0 constant <=
1 varref a
2 varref b
3 constant 200
7 call 3
9 return
And the byte-code-op version:
byte code:
args: nil
0 varref a
1 varref b
2 leq
3 goto-if-nil-else-pop 1
5 varref b
6 constant 200
7 leq
8:1 return
Hundreds of arguments and I’d worry about the extra octets, but there are no
literal calls to these functions with hundreds of arguments (as opposed to
calls constructed with #'apply.) Remember also that the C implementations of
the comparison functions have to loop, too.
Or is there another reason to avoid funcall besides overhead?
One other reason I avoid it is because funcall shows up in profiling
information and byte codes don’t, so there’s less noise when I’m trying to
work out why some operation is taking much longer than it should.
--
“Apart from the nine-banded armadillo, man is the only natural host of
Mycobacterium leprae, although it can be grown in the footpads of mice.”
-- Kumar & Clark, Clinical Medicine, summarising improbable leprosy research
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://calypso.tux.org/mailman/listinfo/xemacs-patches
5208
days inactive
5210
days old
2 comments
2 participants
participants (2)
-
Aidan Kehoe -
Stephen J. Turnbull