diff options
| author | Kartik K. Agaram <vc@akkartik.com> | 2016-09-17 15:01:51 -0700 |
|---|---|---|
| committer | Kartik K. Agaram <vc@akkartik.com> | 2016-09-17 15:01:51 -0700 |
| commit | f344b250f6f062a1a1902bf69b23ebf9b565de0e (patch) | |
| tree | 199bd32a9aee198d5028b1c21b83d2cf0944b2b6 /html/074deep_copy.cc.html | |
| parent | 897ae8c1855f830d8819759ea327d147f28a09bf (diff) | |
| download | mu-f344b250f6f062a1a1902bf69b23ebf9b565de0e.tar.gz | |
3395
Diffstat (limited to 'html/074deep_copy.cc.html')
| -rw-r--r-- | html/074deep_copy.cc.html | 184 |
1 files changed, 92 insertions, 92 deletions
diff --git a/html/074deep_copy.cc.html b/html/074deep_copy.cc.html index b440083b..bd40721c 100644 --- a/html/074deep_copy.cc.html +++ b/html/074deep_copy.cc.html @@ -47,23 +47,23 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color <span class="Delimiter">:(scenario deep_copy_number)</span> def main [ local-scope - <span class="Normal">x</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span> - <span class="Normal">y</span>:number<span class="Special"> <- </span>deep-copy x - <span class="Constant">10</span>:boolean/<span class="Special">raw <- </span>equal x<span class="Delimiter">,</span> y + <span class="Normal">x</span>:num<span class="Special"> <- </span>copy <span class="Constant">34</span> + <span class="Normal">y</span>:num<span class="Special"> <- </span>deep-copy x + <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal x<span class="Delimiter">,</span> y ] <span class="Comment"># non-address primitives are identical</span> <span class="traceContains">+mem: storing 1 in location 10</span> <span class="Delimiter">:(scenario deep_copy_container_without_address)</span> container foo [ - <span class="Normal">x</span>:number - <span class="Normal">y</span>:number + <span class="Normal">x</span>:num + <span class="Normal">y</span>:num ] def main [ local-scope <span class="Normal">a</span>:foo<span class="Special"> <- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span> <span class="Normal">b</span>:foo<span class="Special"> <- </span>deep-copy a - <span class="Constant">10</span>:boolean/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b + <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b ] <span class="Comment"># containers are identical as long as they don't contain addresses</span> <span class="traceContains">+mem: storing 1 in location 10</span> @@ -73,12 +73,12 @@ def main [ def main [ <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span class="Comment"># that the result is deterministic</span> - <span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> - *<span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">34</span> - <span class="Constant">2</span>:address:number<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:address:number - <span class="Constant">10</span>:boolean<span class="Special"> <- </span>equal <span class="Constant">1</span>:address:number<span class="Delimiter">,</span> <span class="Constant">2</span>:address:number - <span class="Constant">11</span>:boolean<span class="Special"> <- </span>equal *<span class="Constant">1</span>:address:number<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:number - <span class="Constant">2</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">0</span> + <span class="Constant">1</span>:&:num<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> + *<span class="Constant">1</span>:&:num<span class="Special"> <- </span>copy <span class="Constant">34</span> + <span class="Constant">2</span>:&:num<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:&:num + <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal <span class="Constant">1</span>:&:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&:num + <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal *<span class="Constant">1</span>:&:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&:num + <span class="Constant">2</span>:&:num<span class="Special"> <- </span>copy <span class="Constant">0</span> ] <span class="Comment"># the result of deep-copy is a new address</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -95,11 +95,11 @@ def main [ def main [ <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span class="Comment"># that the result is deterministic</span> - <span class="Constant">1</span>:address:point<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> - *<span class="Constant">1</span>:address:point<span class="Special"> <- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span> - <span class="Constant">2</span>:address:point<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:address:point - <span class="Constant">10</span>:boolean<span class="Special"> <- </span>equal <span class="Constant">1</span>:address:point<span class="Delimiter">,</span> <span class="Constant">2</span>:address:point - <span class="Constant">11</span>:boolean<span class="Special"> <- </span>equal *<span class="Constant">1</span>:address:point<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:point + <span class="Constant">1</span>:&:point<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> + *<span class="Constant">1</span>:&:point<span class="Special"> <- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span> + <span class="Constant">2</span>:&:point<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:&:point + <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal <span class="Constant">1</span>:&:point<span class="Delimiter">,</span> <span class="Constant">2</span>:&:point + <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal *<span class="Constant">1</span>:&:point<span class="Delimiter">,</span> *<span class="Constant">2</span>:&:point ] <span class="Comment"># the result of deep-copy is a new address</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -111,13 +111,13 @@ def main [ def main [ <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span class="Comment"># that the result is deterministic</span> - <span class="Constant">1</span>:address:address:number<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> - *<span class="Constant">1</span>:address:address:number<span class="Special"> <- </span>copy <span class="Constant">150</span>/unsafe - **<span class="Constant">1</span>:address:address:number<span class="Special"> <- </span>copy <span class="Constant">34</span> - <span class="Constant">2</span>:address:address:number<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:address:address:number - <span class="Constant">10</span>:boolean<span class="Special"> <- </span>equal <span class="Constant">1</span>:address:address:number<span class="Delimiter">,</span> <span class="Constant">2</span>:address:address:number - <span class="Constant">11</span>:boolean<span class="Special"> <- </span>equal *<span class="Constant">1</span>:address:address:number<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:address:number - <span class="Constant">12</span>:boolean<span class="Special"> <- </span>equal **<span class="Constant">1</span>:address:address:number<span class="Delimiter">,</span> **<span class="Constant">2</span>:address:address:number + <span class="Constant">1</span>:&:&:num<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> + *<span class="Constant">1</span>:&:&:num<span class="Special"> <- </span>copy <span class="Constant">150</span>/unsafe + **<span class="Constant">1</span>:&:&:num<span class="Special"> <- </span>copy <span class="Constant">34</span> + <span class="Constant">2</span>:&:&:num<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:&:&:num + <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal <span class="Constant">1</span>:&:&:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&:&:num + <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal *<span class="Constant">1</span>:&:&:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&:&:num + <span class="Constant">12</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal **<span class="Constant">1</span>:&:&:num<span class="Delimiter">,</span> **<span class="Constant">2</span>:&:&:num ] <span class="Comment"># the result of deep-copy is a new address</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -131,18 +131,18 @@ def main [ def main [ <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span class="Comment"># that the result is deterministic</span> - <span class="Constant">100</span>:number<span class="Special"> <- </span>copy <span class="Constant">1</span> <span class="Comment"># pretend refcount</span> - <span class="Constant">101</span>:number<span class="Special"> <- </span>copy <span class="Constant">3</span> <span class="Comment"># pretend array length</span> - <span class="Constant">1</span>:address:array:number<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> - put-index *<span class="Constant">1</span>:address:array:number<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span> - put-index *<span class="Constant">1</span>:address:array:number<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">35</span> - put-index *<span class="Constant">1</span>:address:array:number<span class="Delimiter">,</span> <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">36</span> - stash [old:]<span class="Delimiter">,</span> *<span class="Constant">1</span>:address:array:number - <span class="Constant">2</span>:address:array:number<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:address:array:number - stash <span class="Constant">2</span>:address:array:number - stash [<span class="Normal">new</span>:]<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:array:number - <span class="Constant">10</span>:boolean<span class="Special"> <- </span>equal <span class="Constant">1</span>:address:array:number<span class="Delimiter">,</span> <span class="Constant">2</span>:address:array:number - <span class="Constant">11</span>:boolean<span class="Special"> <- </span>equal *<span class="Constant">1</span>:address:array:number<span class="Delimiter">,</span> *<span class="Constant">2</span>:address:array:number + <span class="Constant">100</span>:num<span class="Special"> <- </span>copy <span class="Constant">1</span> <span class="Comment"># pretend refcount</span> + <span class="Constant">101</span>:num<span class="Special"> <- </span>copy <span class="Constant">3</span> <span class="Comment"># pretend array length</span> + <span class="Constant">1</span>:&:@:num<span class="Special"> <- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> + put-index *<span class="Constant">1</span>:&:@:num<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span> + put-index *<span class="Constant">1</span>:&:@:num<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">35</span> + put-index *<span class="Constant">1</span>:&:@:num<span class="Delimiter">,</span> <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">36</span> + stash [old:]<span class="Delimiter">,</span> *<span class="Constant">1</span>:&:@:num + <span class="Constant">2</span>:&:@:num<span class="Special"> <- </span>deep-copy <span class="Constant">1</span>:&:@:num + stash <span class="Constant">2</span>:&:@:num + stash [<span class="Normal">new</span>:]<span class="Delimiter">,</span> *<span class="Constant">2</span>:&:@:num + <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal <span class="Constant">1</span>:&:@:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&:@:num + <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> <- </span>equal *<span class="Constant">1</span>:&:@:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&:@:num ] <span class="traceContains">+app: old: 3 34 35 36</span> <span class="traceContains">+app: new: 3 34 35 36</span> @@ -153,19 +153,19 @@ def main [ <span class="Delimiter">:(scenario deep_copy_container_with_address)</span> container foo [ - <span class="Normal">x</span>:number - <span class="Normal">y</span>:address:number + <span class="Normal">x</span>:num + <span class="Normal">y</span>:&:num ] def main [ local-scope - <span class="Normal">y0</span>:address:number<span class="Special"> <- </span><span class="Normal">new</span> number:type + <span class="Normal">y0</span>:&:num<span class="Special"> <- </span><span class="Normal">new</span> number:type *y0<span class="Special"> <- </span>copy <span class="Constant">35</span> <span class="Normal">a</span>:foo<span class="Special"> <- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> y0 <span class="Normal">b</span>:foo<span class="Special"> <- </span>deep-copy a - <span class="Constant">10</span>:boolean/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b - <span class="Normal">y1</span>:address:number<span class="Special"> <- </span>get b<span class="Delimiter">,</span> y:offset - <span class="Constant">11</span>:boolean/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 - <span class="Constant">12</span>:number/<span class="Special">raw <- </span>copy *y1 + <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b + <span class="Normal">y1</span>:&:num<span class="Special"> <- </span>get b<span class="Delimiter">,</span> y:offset + <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 + <span class="Constant">12</span>:num/<span class="Special">raw <- </span>copy *y1 ] <span class="Comment"># containers containing addresses are not identical to their deep copies</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -175,19 +175,19 @@ def main [ <span class="Delimiter">:(scenario deep_copy_exclusive_container_with_address)</span> exclusive-container foo [ - <span class="Normal">x</span>:number - <span class="Normal">y</span>:address:number + <span class="Normal">x</span>:num + <span class="Normal">y</span>:&:num ] def main [ local-scope - <span class="Normal">y0</span>:address:number<span class="Special"> <- </span><span class="Normal">new</span> number:type + <span class="Normal">y0</span>:&:num<span class="Special"> <- </span><span class="Normal">new</span> number:type *y0<span class="Special"> <- </span>copy <span class="Constant">34</span> <span class="Normal">a</span>:foo<span class="Special"> <- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> y0 <span class="Normal">b</span>:foo<span class="Special"> <- </span>deep-copy a - <span class="Constant">10</span>:boolean/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b - <span class="Normal">y1</span>:address:number<span class="Delimiter">,</span> z:boolean<span class="Special"> <- </span>maybe-convert b<span class="Delimiter">,</span> y:variant - <span class="Constant">11</span>:boolean/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 - <span class="Constant">12</span>:number/<span class="Special">raw <- </span>copy *y1 + <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal a<span class="Delimiter">,</span> b + <span class="Normal">y1</span>:&:num<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> <- </span>maybe-convert b<span class="Delimiter">,</span> y:variant + <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 + <span class="Constant">12</span>:num/<span class="Special">raw <- </span>copy *y1 ] <span class="Comment"># exclusive containers containing addresses are not identical to their deep copies</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -197,24 +197,24 @@ def main [ <span class="Delimiter">:(scenario deep_copy_exclusive_container_with_container_with_address)</span> exclusive-container foo [ - <span class="Normal">x</span>:number + <span class="Normal">x</span>:num <span class="Normal">y</span>:bar <span class="Comment"># inline</span> ] container bar [ - <span class="Normal">x</span>:address:number + <span class="Normal">x</span>:&:num ] def main [ local-scope - <span class="Normal">y0</span>:address:number<span class="Special"> <- </span><span class="Normal">new</span> number:type + <span class="Normal">y0</span>:&:num<span class="Special"> <- </span><span class="Normal">new</span> number:type *y0<span class="Special"> <- </span>copy <span class="Constant">34</span> <span class="Normal">a</span>:bar<span class="Special"> <- </span>merge y0 <span class="Normal">b</span>:foo<span class="Special"> <- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> a <span class="Normal">c</span>:foo<span class="Special"> <- </span>deep-copy b - <span class="Constant">10</span>:boolean/<span class="Special">raw <- </span>equal b<span class="Delimiter">,</span> c - <span class="Normal">d</span>:bar<span class="Delimiter">,</span> z:boolean<span class="Special"> <- </span>maybe-convert c<span class="Delimiter">,</span> y:variant - <span class="Normal">y1</span>:address:number<span class="Special"> <- </span>get d<span class="Delimiter">,</span> x:offset - <span class="Constant">11</span>:boolean/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 - <span class="Constant">12</span>:number/<span class="Special">raw <- </span>copy *y1 + <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal b<span class="Delimiter">,</span> c + <span class="Normal">d</span>:bar<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> <- </span>maybe-convert c<span class="Delimiter">,</span> y:variant + <span class="Normal">y1</span>:&:num<span class="Special"> <- </span>get d<span class="Delimiter">,</span> x:offset + <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal y0<span class="Delimiter">,</span> y1 + <span class="Constant">12</span>:num/<span class="Special">raw <- </span>copy *y1 ] <span class="Comment"># exclusive containers containing addresses are not identical to their deep copies</span> <span class="traceContains">+mem: storing 0 in location 10</span> @@ -336,83 +336,83 @@ vector<<span class="Normal">double</span>> deep_copy<span class="Delimiter <span class="Delimiter">:(scenario deep_copy_stress_test_1)</span> container foo1 [ - <span class="Normal">p</span>:address:number + <span class="Normal">p</span>:&:num ] container foo2 [ - <span class="Normal">p</span>:address:foo1 + <span class="Normal">p</span>:&:foo1 ] exclusive-container foo3 [ - <span class="Normal">p</span>:address:foo1 - <span class="Normal">q</span>:address:foo2 + <span class="Normal">p</span>:&:foo1 + <span class="Normal">q</span>:&:foo2 ] def main [ local-scope - <span class="Normal">x</span>:address:number<span class="Special"> <- </span><span class="Normal">new</span> number:type + <span class="Normal">x</span>:&:num<span class="Special"> <- </span><span class="Normal">new</span> number:type *x<span class="Special"> <- </span>copy <span class="Constant">34</span> - <span class="Normal">a</span>:address:foo1<span class="Special"> <- </span><span class="Normal">new</span> foo1:type + <span class="Normal">a</span>:&:foo1<span class="Special"> <- </span><span class="Normal">new</span> foo1:type *a<span class="Special"> <- </span>merge x - <span class="Normal">b</span>:address:foo2<span class="Special"> <- </span><span class="Normal">new</span> foo2:type + <span class="Normal">b</span>:&:foo2<span class="Special"> <- </span><span class="Normal">new</span> foo2:type *b<span class="Special"> <- </span>merge a <span class="Normal">c</span>:foo3<span class="Special"> <- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b <span class="Normal">d</span>:foo3<span class="Special"> <- </span>deep-copy c - <span class="Normal">e</span>:address:foo2<span class="Delimiter">,</span> z:boolean<span class="Special"> <- </span>maybe-convert d<span class="Delimiter">,</span> q:variant - <span class="Normal">f</span>:address:foo1<span class="Special"> <- </span>get *e<span class="Delimiter">,</span> p:offset - <span class="Normal">g</span>:address:number<span class="Special"> <- </span>get *f<span class="Delimiter">,</span> p:offset - <span class="Constant">1</span>:number/<span class="Special">raw <- </span>copy *g + <span class="Normal">e</span>:&:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> <- </span>maybe-convert d<span class="Delimiter">,</span> q:variant + <span class="Normal">f</span>:&:foo1<span class="Special"> <- </span>get *e<span class="Delimiter">,</span> p:offset + <span class="Normal">g</span>:&:num<span class="Special"> <- </span>get *f<span class="Delimiter">,</span> p:offset + <span class="Constant">1</span>:num/<span class="Special">raw <- </span>copy *g ] <span class="traceContains">+mem: storing 34 in location 1</span> <span class="Delimiter">:(scenario deep_copy_stress_test_2)</span> container foo1 [ - <span class="Normal">p</span>:address:number + <span class="Normal">p</span>:&:num ] container foo2 [ - <span class="Normal">p</span>:address:foo1 + <span class="Normal">p</span>:&:foo1 ] exclusive-container foo3 [ - <span class="Normal">p</span>:address:foo1 - <span class="Normal">q</span>:address:foo2 + <span class="Normal">p</span>:&:foo1 + <span class="Normal">q</span>:&:foo2 ] container foo4 [ - <span class="Normal">p</span>:number - <span class="Normal">q</span>:address:foo3 + <span class="Normal">p</span>:num + <span class="Normal">q</span>:&:foo3 ] def main [ local-scope - <span class="Normal">x</span>:address:number<span class="Special"> <- </span><span class="Normal">new</span> number:type + <span class="Normal">x</span>:&:num<span class="Special"> <- </span><span class="Normal">new</span> number:type *x<span class="Special"> <- </span>copy <span class="Constant">34</span> - <span class="Normal">a</span>:address:foo1<span class="Special"> <- </span><span class="Normal">new</span> foo1:type + <span class="Normal">a</span>:&:foo1<span class="Special"> <- </span><span class="Normal">new</span> foo1:type *a<span class="Special"> <- </span>merge x - <span class="Normal">b</span>:address:foo2<span class="Special"> <- </span><span class="Normal">new</span> foo2:type + <span class="Normal">b</span>:&:foo2<span class="Special"> <- </span><span class="Normal">new</span> foo2:type *b<span class="Special"> <- </span>merge a - <span class="Normal">c</span>:address:foo3<span class="Special"> <- </span><span class="Normal">new</span> foo3:type + <span class="Normal">c</span>:&:foo3<span class="Special"> <- </span><span class="Normal">new</span> foo3:type *c<span class="Special"> <- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b <span class="Normal">d</span>:foo4<span class="Special"> <- </span>merge <span class="Constant">35</span><span class="Delimiter">,</span> c <span class="Normal">e</span>:foo4<span class="Special"> <- </span>deep-copy d - <span class="Normal">f</span>:address:foo3<span class="Special"> <- </span>get e<span class="Delimiter">,</span> q:offset - <span class="Normal">g</span>:address:foo2<span class="Delimiter">,</span> z:boolean<span class="Special"> <- </span>maybe-convert *f<span class="Delimiter">,</span> q:variant - <span class="Normal">h</span>:address:foo1<span class="Special"> <- </span>get *g<span class="Delimiter">,</span> p:offset - <span class="Normal">y</span>:address:number<span class="Special"> <- </span>get *h<span class="Delimiter">,</span> p:offset - <span class="Constant">1</span>:number/<span class="Special">raw <- </span>copy *y + <span class="Normal">f</span>:&:foo3<span class="Special"> <- </span>get e<span class="Delimiter">,</span> q:offset + <span class="Normal">g</span>:&:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> <- </span>maybe-convert *f<span class="Delimiter">,</span> q:variant + <span class="Normal">h</span>:&:foo1<span class="Special"> <- </span>get *g<span class="Delimiter">,</span> p:offset + <span class="Normal">y</span>:&:num<span class="Special"> <- </span>get *h<span class="Delimiter">,</span> p:offset + <span class="Constant">1</span>:num/<span class="Special">raw <- </span>copy *y ] <span class="traceContains">+mem: storing 34 in location 1</span> <span class="Delimiter">:(scenario deep_copy_cycles)</span> container foo [ - <span class="Normal">p</span>:number - <span class="Normal">q</span>:address:foo + <span class="Normal">p</span>:num + <span class="Normal">q</span>:&:foo ] def main [ local-scope - <span class="Normal">x</span>:address:foo<span class="Special"> <- </span><span class="Normal">new</span> foo:type + <span class="Normal">x</span>:&:foo<span class="Special"> <- </span><span class="Normal">new</span> foo:type *x<span class="Special"> <- </span>put *x<span class="Delimiter">,</span> p:offset<span class="Delimiter">,</span> <span class="Constant">34</span> *x<span class="Special"> <- </span>put *x<span class="Delimiter">,</span> q:offset<span class="Delimiter">,</span> x <span class="Comment"># create a cycle</span> - <span class="Normal">y</span>:address:foo<span class="Special"> <- </span>deep-copy x - <span class="Constant">1</span>:number/<span class="Special">raw <- </span>get *y<span class="Delimiter">,</span> p:offset - <span class="Normal">y2</span>:address:foo<span class="Special"> <- </span>get *y<span class="Delimiter">,</span> q:offset + <span class="Normal">y</span>:&:foo<span class="Special"> <- </span>deep-copy x + <span class="Constant">1</span>:num/<span class="Special">raw <- </span>get *y<span class="Delimiter">,</span> p:offset + <span class="Normal">y2</span>:&:foo<span class="Special"> <- </span>get *y<span class="Delimiter">,</span> q:offset stash y [vs] y2 - <span class="Constant">2</span>:boolean/<span class="Special">raw <- </span>equal y<span class="Delimiter">,</span> y2 <span class="Comment"># is it still a cycle?</span> - <span class="Constant">3</span>:boolean/<span class="Special">raw <- </span>equal x<span class="Delimiter">,</span> y <span class="Comment"># is it the same cycle?</span> + <span class="Constant">2</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal y<span class="Delimiter">,</span> y2 <span class="Comment"># is it still a cycle?</span> + <span class="Constant">3</span>:<span class="Normal">bool</span>/<span class="Special">raw <- </span>equal x<span class="Delimiter">,</span> y <span class="Comment"># is it the same cycle?</span> ] <span class="traceContains">+mem: storing 34 in location 1</span> <span class="Comment"># deep copy also contains a cycle</span> |