Add strings to heap diagrams; fix up a bug in heap diagrams.

Author: dvanhorn

www/notes/diagrams.rkt

@@ -8,6 +8,17 @@
 
 (define n 40)
 
+(define (make-str-cells s)
+  (hc-append 
+   (foldl (λ (c p) 
+            (hc-append p 
+                       (cc-superimpose (rectangle (/ n 2) n) ((current-code-tt) (string c)))))
+          (cc-superimpose (rectangle n n) (code #,(string-length s)))
+          (string->list s))
+   (if (even? (string-length s))
+       (rectangle 0 n)
+       (cc-superimpose (rectangle (/ n 2) n) (code 0)))))                      
+
 (define (make-imm-cell i)
   (cc-superimpose
    (code #,i)
@@ -17,6 +28,9 @@
   (cb-superimpose (rectangle n n)
                   (code cons)))
 
+(define (make-str-cell)
+  (cb-superimpose (rectangle n n)
+                  (code str)))
 
 (define (make-box-cell)
   (cb-superimpose (rectangle n n)
@@ -72,13 +86,16 @@
     [`(cons ,_) (make-cons-cell)]
     [`(box ,_) (make-box-cell)]
     [`(vect ,_) (make-vect-cell)]
+    [`(str ,_) (make-str-cell)]
+    [(? string?) (make-str-cells v)]
     [_ (make-imm-cell v)]))
 
 (define (add-arrows spec cells p)
   ;(printf "~a~n" spec)
   (match spec
     ['() p]
-    [(cons `(_ ,i) s)
+    [(cons `(,_ ,(? integer? i)) s)
+     
      (add-arrows s
                  cells
                  (fwd-pts-to (list-ref cells (sub1 (- (length cells) (length s))))
@@ -99,17 +116,62 @@
                           heap)))
 
      (define heap/arrows/label
-       (vc-append 
-                  0
-                  heap/arrows
-                  (text "heap")))
+       (vc-append 10
+        (vc-append 
+         0
+         heap/arrows
+         (text "heap"))
+        (text "← lower addresses, higher addresses →")))
 
      (define rax/label
-       (vc-append 0 rax (text "rax")))
+       (vc-append 10 (vc-append 0 rax (text "rax"))
+                  (text " ")))
 
      (inset
-      (fwd-pts-to rax (list-ref heap i) (hc-append n rax/label heap/arrows/label))
-      (* n 2))]))
+      (fwd-pts-to rax (list-ref heap i)
+                  (hc-append n rax/label heap/arrows/label))
+      0 (* n 2) 0 0)]))
+
+#;
+(define cons-quiz
+  (list (make-heap-diagram
+         '((cons 4)
+           3
+           '()  
+           2
+           (cons 0)
+           1
+           (cons 2)))
+        (make-heap-diagram
+         '((cons 0)
+           1
+           (cons 2)
+           2
+           (cons 4)
+           3
+           '()))
+        (make-heap-diagram
+         '((cons 4)
+           '()
+           3
+           (cons 0)
+           2
+           (cons 2)
+           1))
+        (make-heap-diagram
+         '((cons 0)
+           (cons 2)
+           1
+           (cons 4)
+           2
+           '()
+           3))
+        ))
+
+
+
+;(text "← lower addresses, higher addresses →")
+
 #;
 (make-heap-diagram
  '((cons 0)

www/notes/hoax.scrbl

@@ -899,6 +899,18 @@ So, suppose we want to create the string @racket["abc"]:
     (Pop rbx)
     (Ret))))
 
+This creates a string in memory like this:
+
+@make-heap-diagram['((str 0) "abc")]
+
+
+In this diagram, we use half-sized boxes to indicate that only 4 bytes
+are used per codepoint.  Also the contents of the array are not
+values, but codepoints (shown as the letters the codepoint encodes).
+In odd length strings, we write @racket[0] for the padded element, but
+in reality there are arbitrary bits at that memory location, which is
+fine because they will never be read.
+
 At first glance, this looks remarkably similar to creating a vector,
 however there are some imporant things to notice:
 
@@ -926,6 +938,18 @@ you are seeing here.}
 
 ]
 
+Notice that a string like @racket["fred"] is not represented the same
+as a vector of characters @racket[#(#\f #\r #\e #\d)], which uses more
+space.  Compare:
+
+@make-heap-diagram['((str 0) "fred")]
+
+versus:
+
+@make-heap-diagram['((vect 0) 4 #\f #\r #\e #\d)]
+
+
+
 Now let's set things up like we did before to be able to interactively
 write examples in order to arrive at the code for
 @racket[string-length], @racket[string-ref], and @racket[make-string]: