This is SBCL 2.0.2, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
* ; compiling file "/home/gilbert/lisp/clex/c/benchc.lisp" (written 29 DEC 2021 10:30:18 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFUN SCAN ...)
; compiling (DEFUN READ-FILE-AS-STRING ...)
; compiling (DEFUN FOO ...)
; compiling (DISASSEMBLE (QUOTE SCAN))
; compiling (PRINT (MULTIPLE-VALUE-LIST #))
; wrote /home/gilbert/lisp/clex/c/benchc.fasl
; compilation finished in 0:00:00.010
; disassembly for SCAN
; Size: 416 bytes. Origin: #x52C56E2D ; SCAN
; E2D: 498B4510 MOV RAX, [R13+16] ; thread.binding-stack-pointer
; E31: 488945F8 MOV [RBP-8], RAX
; E35: BA00000000 MOV EDX, 0
; E3A: 31C9 XOR ECX, ECX
; E3C: 4531D2 XOR R10D, R10D
; E3F: 4531C0 XOR R8D, R8D
; E42: 4531C9 XOR R9D, R9D
; E45: 31F6 XOR ESI, ESI
; E47: 660F1F840000000000 NOP
; E50: L0: 4839CF CMP RDI, RCX
; E53: 7522 JNE L4
; E55: L1: 488BF4 MOV RSI, RSP
; E58: 6817001050 PUSH 1343225879
; E5D: B902000000 MOV ECX, 2
; E62: L2: 4883F902 CMP RCX, 2
; E66: 750A JNE L3
; E68: 488B56F8 MOV RDX, [RSI-8]
; E6C: 488BE5 MOV RSP, RBP
; E6F: F8 CLC
; E70: 5D POP RBP
; E71: C3 RET
; E72: L3: E9F99C4AFF JMP #x52100B70 ; RETURN-MULTIPLE
; E77: L4: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; E7B: 8BD0 MOV EDX, EAX
; E7D: 488D4102 LEA RAX, [RCX+2]
; E81: 488BC8 MOV RCX, RAX
; E84: 4883FA39 CMP RDX, 57
; E88: 77C6 JNBE L0
; E8A: 4883FA2F CMP RDX, 47
; E8E: 76C0 JBE L0
; E90: 488BF1 MOV RSI, RCX
; E93: 660F1F840000000000 NOP
; E9C: 0F1F4000 NOP
; EA0: L5: 4839CF CMP RDI, RCX
; EA3: 74B0 JEQ L1
; EA5: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; EA9: 8BD0 MOV EDX, EAX
; EAB: 488D4102 LEA RAX, [RCX+2]
; EAF: 488BC8 MOV RCX, RAX
; EB2: 4883FA77 CMP RDX, 119
; EB6: 0F86F6000000 JBE L15
; EBC: 4883FA78 CMP RDX, 120
; EC0: 778E JNBE L0
; EC2: 4839CF CMP RDI, RCX
; EC5: 748E JEQ L1
; EC7: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; ECB: 8BD0 MOV EDX, EAX
; ECD: 488D4102 LEA RAX, [RCX+2]
; ED1: 488BC8 MOV RCX, RAX
; ED4: 4883FA39 CMP RDX, 57
; ED8: 0F8772FFFFFF JNBE L0
; EDE: 4883FA2F CMP RDX, 47
; EE2: 0F8668FFFFFF JBE L0
; EE8: 4C8BD1 MOV R10, RCX
; EEB: 0F1F440000 NOP
; EF0: L6: 4839CF CMP RDI, RCX
; EF3: 7517 JNE L8
; EF5: 4C8BCE MOV R9, RSI
; EF8: 4C8BC1 MOV R8, RCX
; EFB: L7: 488BF4 MOV RSI, RSP
; EFE: 4151 PUSH R9
; F00: 4150 PUSH R8
; F02: B904000000 MOV ECX, 4
; F07: E956FFFFFF JMP L2
; F0C: L8: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; F10: 8BD0 MOV EDX, EAX
; F12: 488D4102 LEA RAX, [RCX+2]
; F16: 488BC8 MOV RCX, RAX
; F19: 4883FA77 CMP RDX, 119
; F1D: 766D JBE L13
; F1F: 4883FA78 CMP RDX, 120
; F23: 7608 JBE L9
; F25: 4C8BCE MOV R9, RSI
; F28: 4C8BC1 MOV R8, RCX
; F2B: EBCE JMP L7
; F2D: L9: 4839CF CMP RDI, RCX
; F30: 0F841FFFFFFF JEQ L1
; F36: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; F3A: 8BD0 MOV EDX, EAX
; F3C: 488D4102 LEA RAX, [RCX+2]
; F40: 488BC8 MOV RCX, RAX
; F43: 4883FA39 CMP RDX, 57
; F47: 77B2 JNBE L7
; F49: 4883FA2F CMP RDX, 47
; F4D: 76AC JBE L7
; F4F: 90 NOP
; F50: L10: 4839CF CMP RDI, RCX
; F53: 7508 JNE L11
; F55: 4D8BCA MOV R9, R10
; F58: 4C8BC1 MOV R8, RCX
; F5B: EB9E JMP L7
; F5D: L11: 8B444B01 MOV EAX, [RBX+RCX*2+1]
; F61: 8BD0 MOV EDX, EAX
; F63: 488D4102 LEA RAX, [RCX+2]
; F67: 488BC8 MOV RCX, RAX
; F6A: 4883FA39 CMP RDX, 57
; F6E: 760B JBE L12
; F70: 4D8BCA MOV R9, R10
; F73: 4C8BC1 MOV R8, RCX
; F76: E980FFFFFF JMP L7
; F7B: L12: 4883FA2F CMP RDX, 47
; F7F: 77CF JNBE L10
; F81: 4D8BCA MOV R9, R10
; F84: 4C8BC1 MOV R8, RCX
; F87: E96FFFFFFF JMP L7
; F8C: L13: 4883FA2F CMP RDX, 47
; F90: 7615 JBE L14
; F92: 4883FA39 CMP RDX, 57
; F96: 0F8654FFFFFF JBE L6
; F9C: 4C8BCE MOV R9, RSI
; F9F: 4C8BC1 MOV R8, RCX
; FA2: E954FFFFFF JMP L7
; FA7: L14: 4C8BCE MOV R9, RSI
; FAA: 4C8BC1 MOV R8, RCX
; FAD: E949FFFFFF JMP L7
; FB2: L15: 4883FA2F CMP RDX, 47
; FB6: 0F8694FEFFFF JBE L0
; FBC: 4883FA39 CMP RDX, 57
; FC0: 0F878AFEFFFF JNBE L0
; FC6: E9D5FEFFFF JMP L5
; FCB: CC10 INT3 16 ; Invalid argument count trap
(5.820326049254249d8 (1676 1679))
T
* ;; This is ~/.ccl-init.lisp
;; asdf:*central-registry* = ((TRUENAME "home:lisp;system;") (TRUENAME ".") #P"/home/gilbert/quicklisp/quicklisp/")
Welcome to Clozure Common Lisp Version 1.11-r16635 (LinuxX8664)!
CCL is developed and maintained by Clozure Associates. For more information
about CCL visit http://ccl.clozure.com. To enquire about Clozure's Common Lisp
consulting services e-mail info@clozure.com or visit http://www.clozure.com.
? ;Loading #P"/home/gilbert/lisp/clex/c/benchc.lx64fsl"...;; "benchc.lisp":6289-8526
(recover-fn-from-rip) ; [7]
(cmpl ($ 16) (% nargs)) ; [14]
(jne L729) ; [17]
(pushq (% rbp)) ; [23]
(movq (% rsp) (% rbp)) ; [24]
(pushq (% arg_y)) ; [27]
(pushq (% arg_z)) ; [28]
(pushq (% save0)) ; [29]
(pushq (% save1)) ; [31]
(pushq (% save2)) ; [33]
(pushq (% save3)) ; [35]
;;; (PROG ((CH #\Null) (P 0) (R.3 0) ($0.E 0) ($0.S 0) (R.2 0)) (DECLARE (TYPE FIXNUM P R.3 $0.E $0.S R.
(movl ($ 2) (% save1.l)) ; [37]
(xorl (% save0.l) (% save0.l)) ; [43]
(pushq ($ 0)) ; [46]
(xorl (% save2.l) (% save2.l)) ; [48]
(xorl (% save3.l) (% save3.l)) ; [51]
(pushq ($ 0)) ; [54]
;;; (= P END)
L49
(movq (@ -16 (% rbp)) (% arg_z)) ; [56]
(cmpq (% arg_z) (% save0)) ; [60]
(je L685) ; [63]
;;; (AREF INPUT P)
(movq (@ -8 (% rbp)) (% arg_y)) ; [69]
(movq (% save0) (% imm0)) ; [73]
(shrq (% imm0)) ; [76]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [79]
(shll ($ 8) (% imm0.l)) ; [83]
(leaq (@ 2 (% imm0)) (% save1)) ; [86]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [90]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
(movq (% save1) (% arg_z)) ; [94]
(shrq ($ 5) (% arg_z)) ; [97]
(cmpq ($ #x1C8) (% arg_z)) ; [101]
(jg L49) ; [108]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [110]
(shrq ($ 5) (% arg_z)) ; [113]
(cmpq ($ #x178) (% arg_z)) ; [117]
(jle L49) ; [124]
;;; (SETQ R.2 P)
(movq (% save0) (@ -64 (% rbp))) ; [126]
;;; (GO 6)
(jmpq L380) ; [130]
;;; (= P END)
L128
(movq (@ -16 (% rbp)) (% arg_z)) ; [135]
(cmpq (% arg_z) (% save0)) ; [139]
(jne L149) ; [142]
;;; (SETQ $0.S R.2 $0.E P)
(movq (@ -64 (% rbp)) (% save3)) ; [144]
(movq (% save0) (% save2)) ; [148]
;;; (GO 2)
(jmpq L653) ; [151]
;;; (AREF INPUT P)
L149
(movq (@ -8 (% rbp)) (% arg_y)) ; [156]
(movq (% save0) (% imm0)) ; [160]
(shrq (% imm0)) ; [163]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [166]
(shll ($ 8) (% imm0.l)) ; [170]
(leaq (@ 2 (% imm0)) (% save1)) ; [173]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [177]
;;; (CHAR<= CH (CODE-CHAR (1- 120)))
(movq (% save1) (% arg_z)) ; [181]
(shrq ($ 5) (% arg_z)) ; [184]
(cmpq ($ #x3B8) (% arg_z)) ; [188]
(jg L246) ; [195]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [197]
(shrq ($ 5) (% arg_z)) ; [200]
(cmpq ($ #x178) (% arg_z)) ; [204]
(jg L218) ; [211]
;;; (SETQ $0.S R.2 $0.E P)
(movq (@ -64 (% rbp)) (% save3)) ; [213]
(movq (% save0) (% save2)) ; [217]
;;; (GO 2)
(jmpq L653) ; [220]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
L218
(movq (% save1) (% arg_z)) ; [225]
(shrq ($ 5) (% arg_z)) ; [228]
(cmpq ($ #x1C8) (% arg_z)) ; [232]
(jle L128) ; [239]
;;; (SETQ $0.S R.2 $0.E P)
(movq (@ -64 (% rbp)) (% save3)) ; [241]
(movq (% save0) (% save2)) ; [245]
;;; (GO 2)
(jmpq L653) ; [248]
;;; (CHAR<= CH (CODE-CHAR (1- 121)))
L246
(movq (% save1) (% arg_z)) ; [253]
(shrq ($ 5) (% arg_z)) ; [256]
(cmpq ($ #x3C0) (% arg_z)) ; [260]
(jle L583) ; [267]
;;; (SETQ $0.S R.2 $0.E P)
(movq (@ -64 (% rbp)) (% save3)) ; [273]
(movq (% save0) (% save2)) ; [277]
;;; (GO 2)
(jmpq L653) ; [280]
;;; (= P END)
L278
(movq (@ -16 (% rbp)) (% arg_z)) ; [285]
(cmpq (% arg_z) (% save0)) ; [289]
(jne L299) ; [292]
;;; (SETQ $0.S R.3 $0.E P)
(movq (@ -56 (% rbp)) (% save3)) ; [294]
(movq (% save0) (% save2)) ; [298]
;;; (GO 2)
(jmpq L653) ; [301]
;;; (AREF INPUT P)
L299
(movq (@ -8 (% rbp)) (% arg_y)) ; [306]
(movq (% save0) (% imm0)) ; [310]
(shrq (% imm0)) ; [313]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [316]
(shll ($ 8) (% imm0.l)) ; [320]
(leaq (@ 2 (% imm0)) (% save1)) ; [323]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [327]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
(movq (% save1) (% arg_z)) ; [331]
(shrq ($ 5) (% arg_z)) ; [334]
(cmpq ($ #x1C8) (% arg_z)) ; [338]
(jg L368) ; [345]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [347]
(shrq ($ 5) (% arg_z)) ; [350]
(cmpq ($ #x178) (% arg_z)) ; [354]
(jg L278) ; [361]
;;; (SETQ $0.S R.3 $0.E P)
(movq (@ -56 (% rbp)) (% save3)) ; [363]
(movq (% save0) (% save2)) ; [367]
;;; (GO 2)
(jmpq L653) ; [370]
;;; (SETQ $0.S R.3 $0.E P)
L368
(movq (@ -56 (% rbp)) (% save3)) ; [375]
(movq (% save0) (% save2)) ; [379]
;;; (GO 2)
(jmpq L653) ; [382]
;;; (= P END)
L380
(movq (@ -16 (% rbp)) (% arg_z)) ; [387]
(cmpq (% arg_z) (% save0)) ; [391]
(je L685) ; [394]
;;; (AREF INPUT P)
(movq (@ -8 (% rbp)) (% arg_y)) ; [400]
(movq (% save0) (% imm0)) ; [404]
(shrq (% imm0)) ; [407]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [410]
(shll ($ 8) (% imm0.l)) ; [414]
(leaq (@ 2 (% imm0)) (% save1)) ; [417]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [421]
;;; (CHAR<= CH (CODE-CHAR (1- 120)))
(movq (% save1) (% arg_z)) ; [425]
(shrq ($ 5) (% arg_z)) ; [428]
(cmpq ($ #x3B8) (% arg_z)) ; [432]
(jg L475) ; [439]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [441]
(shrq ($ 5) (% arg_z)) ; [444]
(cmpq ($ #x178) (% arg_z)) ; [448]
(jle L49) ; [455]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
(movq (% save1) (% arg_z)) ; [461]
(shrq ($ 5) (% arg_z)) ; [464]
(cmpq ($ #x1C8) (% arg_z)) ; [468]
(jle L380) ; [475]
;;; (GO 3)
(jmpq L49) ; [477]
;;; (CHAR<= CH (CODE-CHAR (1- 121)))
L475
(movq (% save1) (% arg_z)) ; [482]
(shrq ($ 5) (% arg_z)) ; [485]
(cmpq ($ #x3C0) (% arg_z)) ; [489]
(jle L496) ; [496]
;;; (GO 3)
(jmpq L49) ; [498]
;;; (= P END)
L496
(movq (@ -16 (% rbp)) (% arg_z)) ; [503]
(cmpq (% arg_z) (% save0)) ; [507]
(je L685) ; [510]
;;; (AREF INPUT P)
(movq (@ -8 (% rbp)) (% arg_y)) ; [516]
(movq (% save0) (% imm0)) ; [520]
(shrq (% imm0)) ; [523]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [526]
(shll ($ 8) (% imm0.l)) ; [530]
(leaq (@ 2 (% imm0)) (% save1)) ; [533]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [537]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
(movq (% save1) (% arg_z)) ; [541]
(shrq ($ 5) (% arg_z)) ; [544]
(cmpq ($ #x1C8) (% arg_z)) ; [548]
(jg L49) ; [555]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [561]
(shrq ($ 5) (% arg_z)) ; [564]
(cmpq ($ #x178) (% arg_z)) ; [568]
(jle L49) ; [575]
;;; (SETQ R.3 P)
(movq (% save0) (@ -56 (% rbp))) ; [581]
;;; (GO 4)
(jmpq L128) ; [585]
;;; (= P END)
L583
(movq (@ -16 (% rbp)) (% arg_z)) ; [590]
(cmpq (% arg_z) (% save0)) ; [594]
(je L685) ; [597]
;;; (AREF INPUT P)
(movq (@ -8 (% rbp)) (% arg_y)) ; [599]
(movq (% save0) (% imm0)) ; [603]
(shrq (% imm0)) ; [606]
(movl (@ -5 (% arg_y) (% imm0)) (% imm0.l)) ; [609]
(shll ($ 8) (% imm0.l)) ; [613]
(leaq (@ 2 (% imm0)) (% save1)) ; [616]
;;; (+ P 1)
(addq ($ 8) (% save0)) ; [620]
;;; (CHAR<= CH (CODE-CHAR (1- 58)))
(movq (% save1) (% arg_z)) ; [624]
(shrq ($ 5) (% arg_z)) ; [627]
(cmpq ($ #x1C8) (% arg_z)) ; [631]
(jg L653) ; [638]
;;; (CHAR<= CH (CODE-CHAR (1- 48)))
(movq (% save1) (% arg_z)) ; [640]
(shrq ($ 5) (% arg_z)) ; [643]
(cmpq ($ #x178) (% arg_z)) ; [647]
(jg L278) ; [654]
;;; (VALUES $0.S $0.E)
L653
(pushq (% save3)) ; [660]
(pushq (% save2)) ; [662]
(movl ($ 16) (% nargs)) ; [664]
(movq (@ -48 (% rbp)) (% save3)) ; [669]
(movq (@ -40 (% rbp)) (% save2)) ; [673]
(movq (@ -32 (% rbp)) (% save1)) ; [677]
(movq (@ -24 (% rbp)) (% save0)) ; [681]
(lisp-jump (@ .SPNVALRET)) ; [685]
;;; (RETURN NIL)
L685
(movl ($ #x1300B) (% arg_z.l)) ; [692]
(addq ($ 16) (% rsp)) ; [697]
(popq (% save3)) ; [701]
(popq (% save2)) ; [703]
(popq (% save1)) ; [705]
(popq (% save0)) ; [707]
(leaveq) ; [709]
(retq) ; [710]
;;; #
L729
(uuo-error-wrong-number-of-args) ; [736]
(9.756341476603096D+8 (1676 1679))
#P"/home/gilbert/lisp/clex/c/benchc.lx64fsl"
?
-- bench2.lisp --------------------------------------------------------------------------------
(in-package :cl-user)
(defun scan (input end)
(DECLARE (TYPE FIXNUM END) (TYPE (SIMPLE-ARRAY CHARACTER (*)) INPUT))
(PROG ((CH #\Null) (P 0) (R.3 0) ($0.E 0) ($0.S 0) (R.2 0))
(DECLARE (TYPE FIXNUM P R.3 $0.E $0.S R.2) (TYPE CHARACTER CH)
(OPTIMIZE (SPEED 3) (SAFETY 0)))
3
(WHEN (= P END) (GO 1))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(IF (CHAR<= CH (CODE-CHAR (1- 58)))
(IF (CHAR<= CH (CODE-CHAR (1- 48)))
(GO 3)
(PROGN (SETQ R.2 P) (GO 6)))
(GO 3))
4
(WHEN (= P END) (SETQ $0.S R.2 $0.E P) (GO 2))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(IF (CHAR<= CH (CODE-CHAR (1- 120)))
(IF (CHAR<= CH (CODE-CHAR (1- 48)))
(PROGN (SETQ $0.S R.2 $0.E P) (GO 2))
(IF (CHAR<= CH (CODE-CHAR (1- 58)))
(GO 4)
(PROGN (SETQ $0.S R.2 $0.E P) (GO 2))))
(IF (CHAR<= CH (CODE-CHAR (1- 121)))
(GO 8)
(PROGN (SETQ $0.S R.2 $0.E P) (GO 2))))
5
(WHEN (= P END) (SETQ $0.S R.3 $0.E P) (GO 2))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(IF (CHAR<= CH (CODE-CHAR (1- 58)))
(IF (CHAR<= CH (CODE-CHAR (1- 48)))
(PROGN (SETQ $0.S R.3 $0.E P) (GO 2))
(GO 5))
(PROGN (SETQ $0.S R.3 $0.E P) (GO 2)))
6
(WHEN (= P END) (GO 1))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(IF (CHAR<= CH (CODE-CHAR (1- 120)))
(IF (CHAR<= CH (CODE-CHAR (1- 48)))
(GO 3)
(IF (CHAR<= CH (CODE-CHAR (1- 58))) (GO 6) (GO 3)))
(IF (CHAR<= CH (CODE-CHAR (1- 121))) (GO 7) (GO 3)))
7
(WHEN (= P END) (GO 1))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(IF (CHAR<= CH (CODE-CHAR (1- 58)))
(IF (CHAR<= CH (CODE-CHAR (1- 48)))
(GO 3)
(PROGN (SETQ R.3 P) (GO 4)))
(GO 3))
8
(WHEN (= P END) (GO 1))
(SETQ CH (AREF INPUT P))
(SETQ P (THE FIXNUM (+ P 1)))
(WHEN (CHAR<= CH (CODE-CHAR (1- 58)))
(UNLESS (CHAR<= CH (CODE-CHAR (1- 48))) (GO 5)))
2
(RETURN (VALUES (1- $0.S) (1- $0.E)))
1
(RETURN NIL)))
(defun read-file-as-string (filename)
(with-open-file (input filename)
(let* ((n (file-length input))
(r (make-array n :element-type 'character)))
(read-sequence r input)
r)))
(defun foo ()
(let* ((buf (read-file-as-string "Xorg.0.log"))
(end (length buf)))
(multiple-value-bind (s e) (scan buf end)
(let ((t1 (get-internal-real-time)))
(loop repeat 1000000 do (scan buf end))
(values
(coerce (/ (* 1000000 e) (/ (- (get-internal-real-time) t1) internal-time-units-per-second))
'double-float)
s e)))))
(disassemble'scan)
(print (multiple-value-list (foo)))