Re: [PATCH] use tail pointer for LOOP

[tomas@tuxteam.de]

[-- Attachment #1.1: Type: text/plain, Size: 943 bytes --]

On Thu, Jun 17, 2010 at 09:18:28AM +0200, Thien-Thi Nguyen wrote:
> () tomas@tuxteam.de
> () Thu, 17 Jun 2010 07:10:21 +0200
> 
>    Still, reversing seems to be worth it (by some 30 percent).
>    Unless we find some way to streamline the tail pointer better.
> 
> How does this variant fare?
> 
> (defun copy3 (lst)
>   "Return a copy of LST."
>   (let* ((box (list nil))
>          (tp box))
>     (while lst
>       (setq tp (cdr (nconc tp (list (pop lst))))))
>     (cdr box)))

Cute. You all are successfully keeping me from work. Enjoing it ;-)

Here are the results. Attached the modified source.

  copy1: (1.058881 5 0.7366780000000048)
  copy2: (1.27958 6 0.8913360000000026)
  copy3: (1.337353 6 0.9249420000000015)

Still the reverse version is the winner. Yours seems to be a tad slower
(although I wouldn't know whether it's in the noise).

But  it looks so sharp ;-)

Thanks, regards
-- tomás


[-- Attachment #1.2: bm.el --]
[-- Type: text/plain, Size: 1403 bytes --]

;; This buffer is for notes you don't want to save, and for Lisp evaluation.
;; If you want to create a file, visit that file with C-x C-f,
;; then enter the text in that file's own buffer.

(defun copy1 (lst)
  "Build up a copy of lst by consing up in reverse order, then
reversing"
  (let ((res))
    (while lst
      (setq res (cons (car lst) res)
            lst (cdr lst)))
    (nreverse res)))

(defun copy2 (lst)
  "Build up a copy of lst by consing up in order, keeping a tail
pointer"
  (when lst
    (let ((res) (tail))
      (setq res (cons (car lst) nil)
            tail res
            lst (cdr lst))
      (while lst
        (setcdr tail (cons (car lst) nil))
        (setq tail (cdr tail)
              lst (cdr lst)))
      res)))

(defun copy3 (lst)
  "Return a copy of LST."
  (let* ((box (list nil))
         (tp box))
    (while lst
      (setq tp (cdr (nconc tp (list (pop lst))))))
    (cdr box)))

(defun do-benchmark (n)
  (let ((lst))
    (while (> n 0)
      (setq lst (cons n lst)
            n (1- n)))
    (garbage-collect)
    (message (concat "copy1: %S\n"
                     "copy2: %S\n"
                     "copy3: %S\n")
            (benchmark-run (copy1 lst))
            (benchmark-run (copy2 lst))
            (benchmark-run (copy3 lst)))))

(byte-compile 'copy1)
(byte-compile 'copy2)
(byte-compile 'copy3)
(byte-compile 'do-benchmark)

(do-benchmark 1000000)

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 189 bytes --]