This document summarizes a class lecture on imperative programming. It discusses list appending vs mutable list appending and how the latter does not create new cons cells. It then compares the performance of list appending vs built-in append for immutable lists. Mutable list reversing is discussed, with an exercise to implement mlist-reverse! efficiently without extra consing. Students are reminded that problem set 5 is due Friday unless they provide feedback on exercises or the online course book, in which case it can be turned in on Monday.

1. Class 24:
Imperative
Programming
cs1120 Fall 2011
David Evans
19 October 2011

2. Menu Running time
practice throughout!
Recap: list-append vs. mlist-append!
Aliasing
mlist-reverse!
I haven’t yet written solutions to the Chapter 9 Exercises, but I will do it soon if
at least 3 people provide some evidence that they are trying to solve them!
You can do this by posting your solutions or questions as comments on today’s
class. I also how to see more comments/suggestions for the ElevenLearning
version of the book (post here: http://www.cs.virginia.edu/cs1120/all/2011/on-
line-version-of-course-book). If you do at least one of these, you can turn in
PS5 at Monday’s class with no penalty.

3. Appending vs. Appending!
(define (list-append p q) (define (mlist-append! p q)
(if (null? p) q (if (null? p)
(cons
(car p) (if (null? (mcdr p))
(list-append (cdr p) q))))
(mlist-append! (mcdr p) q))))
Running time:
Memory use:
3

4. Appending vs. Appending!
(define (mlist-append! p q)
(define (list-append p q)
(if (null? p)
(if (null? p) q
(error “Cannot append to empty!”)
(cons
(if (null? (mcdr p))
(car p)
(set-mcdr! p q)
(list-append (cdr p) q))))
(mlist-append! (mcdr p) q))))
Running time in
(Np), Np is number of Running time in
elements in p (Np), number of elements
in p
Number of new cons
cells: (Np) Number of new cons cells: 0
4

5. Does it matter?
To test: Define a procedure to make a list of length n.
5

6. (define (make-list n)
(if (= n 0) null
> (define p1 (make-list 100000))
(cons 0 (make-list (- n 1)))))
> (define p2 (make-list 100000))
> (time (begin (list-append p1 p2) (void)))
cpu time: 78 real time: 77 gc time: 47 (define (make-mlist n)
> (length p1) (if (= n 0) null
100000 (mcons 0 (make-mlist (- n 1)))))
> (define m1 (make-mlist 100000))
> (define m2 (make-mlist 100000)) > (time (begin (list-append p1 p2) (void)))
> (time (mlist-append! m1 m2)) cpu time: 78 real time: 77 gc time: 47
cpu time: 0 real time: 13 gc time: 0 > (time (begin (list-append p1 p2) (void)))
> (mlength m1) cpu time: 78 real time: 83 gc time: 31
200000 > (time (begin (list-append p1 p2) (void)))
> (time (mlist-append! m1 m2)) cpu time: 78 real time: 73 gc time: 31
> (time (begin (list-append p1 p2) (void)))
cpu time: 31 real time: 26 gc time: 0
cpu time: 93 real time: 90 gc time: 31
> (time (mlist-append! m1 m2))
6

7. > (time (begin (append p1 p2) (void)))
cpu time: 0 real time: 1 gc time: 0
> (time (begin (append p1 p2) (void)))
cpu time: 0 real time: 2 gc time: 0
> (define p200k (append p1 p2))
> (define p400k (append p200k p200k))
> (define p800k (append p400k p400k))
What about > (define p1600k (append p800k p800k))
> (length p1600k)
the built-in 1600000
> (time (begin (append p400k p400k) (void)))
cpu time: 0 real time: 6 gc time: 0
append? > (time (begin (append p800k p800k) (void)))
cpu time: 109 real time: 110 gc time: 94
> (time (begin (append p1600k p1600k) (void)))
cpu time: 1045 real time: 1044 gc time: 999
> (time (begin (append p1600k p1600k) (void)))
Possible reason built-in append is so much faster:real time: 160 gc time: 125
cpu time: 171
Internal list representation doesn’t > (time (begin (append p1600k p1600k) (void)))
have to be just cons
pairs (could jump quickly over many cells) 203 real time: 197 gc time: 171
cpu time:
Because lists are immutable, doesn’t have to copy list!
7

8. What about the built-in mappend!
> (require racket/mpair)
> (time (begin (mappend! m1 m2) (void)))
cpu time: 0 real time: 1 gc time: 0
> (time (begin (mappend! m1 m2) (void)))
cpu time: 0 real time: 1 gc time: 0
> (time (begin (mappend! m1 m2) (void)))
8

9. Still waiting…
Favorite response to Exam Question 14:
What topics to you hope to see in the remainder of the
course?:
“I can’t even begin to anticipate
what will come next – most of
what we’ve done so far has
already blown my mind.”
9

10. 10

11. Why We’re Still Waiting / Blowing our Minds?
m1:
1 2 3
m2:
4 5 6
(define (mlist-append! p q)
(if (null? p) (mlist-append! m1 m2)
(error “Cannot append to empty!”) (mlist-append! m1 m2)
(if (null? (mcdr p)) (mlist-append! m1 m2)
(set-mcdr! p q)
(mlist-append! (mcdr p) q))))

12. Aliasing
m1:
1 2 3
> (mlist-append! m1 m2) m2:
> m1 7
4 5 6
{1 2 3 4 5 6}
> m2
{4 5 6}
> (set-mcar! m2 7)
> m2
{7 5 6}
> m1
{1 2 3 7 5 6}

13. Aliasing Problems
m1:
1 2 3
m2:
4 5 6
> (mlist-append! m1 m2)
> (mlist-append! m1 m2)
> (mlist-length m1) (define (mlist-length p)
(if (null? p) 0
(+ 1 (mlist-length (mcdr p)))))

14. Reversing
14

15. Analyzing list-reverse
(define (list-reverse p)
(if (null? p) null
(list-append (list-reverse (cdr p)) (list (car p)))))
15

16. Reversing
(define (list-reverse p)
(if (null? p) null
(list-append (list-reverse (cdr p)) (list (car p)))))
Running time is in (N2)
where N is number of elements in p.
Number of new cons cells:
for the list-appends: N-1 + N-2 + … + 1 = N2/ 2
+ for the (list (car p)): N
memory use is in (N2)
16

17. mlist-reverse!
Define a mlist-reverse! that reverses the elements of a
mutable list. The output should be a mutable list with
the elements in the reverse order. The number of cons
cells it creates should not scale with the length of the
list. (The input list can be mutated arbitrarily!)
17

18. Charge
PS5 Due Friday
Except as noted earlier: if you post a
comment/suggestion about the
ElevenLearning book or a comment that
suggests you are trying the Chapter 9 book
exercises then it is due Monday