Question

list和make-list的汇编代码有些不同（在SBCL中），即使最终结果相同：

* (disassemble (lambda (x) (list x)))
; disassembly for (LAMBDA (X))
; Size: 77 bytes. Origin: #x10025C0064
; 64:       498B4560         MOV RAX, [R13+96]                ; no-arg-parsing entry point
                                                              ; thread.binding-stack-pointer
; 68:       488945F8         MOV [RBP-8], RAX
; 6C:       840425F8FF1020   TEST AL, [#x2010FFF8]            ; safepoint
; 73:       4D8B5D20         MOV R11, [R13+32]                ; thread.alloc-region
; 77:       498D4310         LEA RAX, [R11+16]
; 7B:       493B4528         CMP RAX, [R13+40]
; 7F:       7725             JNBE L1
; 81:       49894520         MOV [R13+32], RAX                ; thread.alloc-region
; 85: L0:   498D4307         LEA RAX, [R11+7]
; 89:       840425F8FF1020   TEST AL, [#x2010FFF8]            ; safepoint
; 90:       488950F9         MOV [RAX-7], RDX
; 94:       C7400117001120   MOV DWORD PTR [RAX+1], #x20110017  ; NIL
; 9B:       488BD0           MOV RDX, RAX
; 9E:       488BE5           MOV RSP, RBP
; A1:       F8               CLC
; A2:       5D               POP RBP
; A3:       C3               RET
; A4:       CC0F             BREAK 15                         ; Invalid argument count trap
; A6: L1:   6A10             PUSH 16
; A8:       FF142528000020   CALL QWORD PTR [#x20000028]      ; ALLOC-TRAMP-R11
; AF:       EBD4             JMP L0
NIL

* (disassemble (lambda (x) (make-list 1 :initial-element x)))
; disassembly for (LAMBDA (X))
; Size: 43 bytes. Origin: #x10025C0127
; 27:       498B5D60         MOV RBX, [R13+96]                ; no-arg-parsing entry point
                                                              ; thread.binding-stack-pointer
; 2B:       48895DF8         MOV [RBP-8], RBX
; 2F:       840425F8FF1020   TEST AL, [#x2010FFF8]            ; safepoint
; 36:       BA02000000       MOV EDX, 2
; 3B:       488BFE           MOV RDI, RSI
; 3E:       488B0593FFFFFF   MOV RAX, [RIP-109]               ; #<SB-KERNEL:FDEFN SB-KERNEL:%MAKE-LIST>
; 45:       B904000000       MOV ECX, 4
; 4A:       FF7508           PUSH QWORD PTR [RBP+8]
; 4D:       FF6009           JMP QWORD PTR [RAX+9]
; 50:       CC0F             BREAK 15                         ; Invalid argument count trap
NIL
*

但是请注意，(disassemble (lambda (x) (cons x nil)))和(disassemble (lambda (x) (list x)))似乎产生相同的代码。

(disassemble (lambda (x) (vector x)))和(disassemble (lambda (x) (make-array 1 :initial-element x)))表现出相同的差异。

在编译器优化之后，list或make-list（以及vector或make-array中的一个效率更高吗？

此外，list或vector（以及make-list或make-array中的一个）效率是否更高（暂时忽略随后如何访问和更新序列）？

Answer 1

我不清楚如何比较// Read the query to an array $data = array(); while (($row = mysql_fetch_array($result, MYSQL_ASSOC)) !== false){ $data[] = $row; } $num_db_rows = count($data); // Display random rows: $NUM_DISPLAY_ROWS = 12; // Or any other number: for ($i = 0; $i < $NUM_DISPLAY_ROWS; ++$i) { $row = $data[rand(0, $num_db_rows - 1)]; // Display this row... }和list，因为它们的用途完全不同。它们都返回列表的事实并不能使它们相似或可比。

因此，假设有人想对make-list的表现有所了解。以下代码可以做到这一点：

make-list

首先要注意的是执行时间不一致，因为除了（例如GC）之外，系统中还有太多其他“随机”事件在进行。更重要的是，我们现在如何编写10,000,000个0列表以传递给* (let ((lst (time (make-list 10000000 :initial-element 0)))) (if lst t nil)) Evaluation took: 0.344 seconds of real time 0.343750 seconds of total run time (0.187500 user, 0.156250 system) [ Run times consist of 0.251 seconds GC time, and 0.093 seconds non-GC time. ] 100.00% CPU 1,129,211,079 processor cycles 160,170,016 bytes consed T * (let ((lst (time (make-list 10000000 :initial-element 0)))) (if lst t nil)) Evaluation took: 0.188 seconds of real time 0.187500 seconds of total run time (0.125000 user, 0.062500 system) [ Run times consist of 0.139 seconds GC time, and 0.049 seconds non-GC time. ] 100.00% CPU 632,759,465 processor cycles 160,195,440 bytes consed T * (let ((lst (time (make-list 10000000 :initial-element 0)))) (if lst t nil)) Evaluation took: 0.343 seconds of real time 0.343750 seconds of total run time (0.187500 user, 0.156250 system) [ Run times consist of 0.266 seconds GC time, and 0.078 seconds non-GC time. ] 100.29% CPU 1,151,984,724 processor cycles 160,170,016 bytes consed T * (let ((lst (time (make-list 10000000 :initial-element 0)))) (if lst t nil)) Evaluation took: 0.203 seconds of real time 0.203125 seconds of total run time (0.171875 user, 0.031250 system) [ Run times consist of 0.140 seconds GC time, and 0.064 seconds non-GC time. ] 100.00% CPU 648,536,502 processor cycles 160,195,520 bytes consed T进行比较？我们是否使用一个循环（在这种情况下，这将是{通常}是计时的循环）？我们是否首先创建一个打印的表示形式，即一个10,000,000长的0列表，然后用list进行读取（在这种情况下，我们将{主要}安排创建打印的表示形式和Lisp阅读器）？在我看来像苹果和桔子...

Answer 2

据我了解，编译器优化后，make-list和make-array效率更高。例如，使用make-list，您可以在创建列表后立即控制该列表的大小，并且在反汇编该函数时，应该会看到“ invalid-args-count-error”，该错误会优化代码。您从一开始就声明该列表的大小，而使用列表功能除了列表最大大小的限制外，没有其他优化方法：

(setq x (make-list 4 :initial-element 'a))

相比

(setq x (list 'a 'a 'a 'a))

如果您尝试使用make-list向索引5添加元素，则会发生索引过大的错误，而使用list函数创建列表时不会发生这种情况。缺点会破坏您描述的方式，并且与列表或向量更相似，因为对大小和类型没有限制：

(cons 1 '(a b c d e))

相比：

(make-array '(2 3) :initial-element nil
                   :element-type 'fixnum)

这将限制大小，并且仅创建指向fixnums的指针。就代码优化而言，make-array和make-list效率更高，但是您当然可以声明向量将是某种类型和某种大小，这将优化您的代码：

(declaim (type (vector fixnum 20) v))

在那之后，编译器优化向量在发送被读取之前应该与make-array之类的函数一样有效。

比较Common Lisp中的清单/制作清单和向量/制作阵列

2 个答案: