1. Automating Memory Management

2. Dumb Pointers
Pointers Necessary
Dynamic memory
Sharing memory

3. Dumb Pointers Pointers Necessary But they are tricky Dynamic memory
Sharing memory
But they are tricky
Memory leaks
Bad pointers

4. References
References : safer pointers
C++ :
Non-nullable

5. References Java : All objects are on heap Stack has
Numeric Variables
References
References are nullable
Cannot delete memory

6. References
Python
Everything is a reference… even numbers
x = 1 1 x

7. References Python x = 1 x = 2 Everything is a reference… even numbers

8. References Python x = 1 x = 2 y = x
Everything is a reference… even numbers
x = 1 x = 2 y = x 1 x 2 y

9. References Python x = 1 x = 2 y = x x = 4
Everything is a reference… even numbers
x = 1 x = 2 y = x x = 4 1 x 2 y 4

10. References Python x = 1 x = 2 y = x x = 4 x = x + 1
Everything is a reference… even numbers
x = 1 x = 2 y = x x = 4 x = x + 1 1 x 2 y 4 5

11. Garbage Collection Garbage collection:
Automatically reclaim unused memory from heap
Various strategies
Reference counting
Mark and Sweep

12. Reference Counting Store count of references to each heap allocation
0 references = garbage
Once removed, things they point to may become 0 count

13. Reference Counting
Problem:
Cycles are not identified

14. Mark & Sweep Mark all heap allocations as dead
Start from stack based variables
Traverse pointers and mark hit allocations live
Delete dead memory

15. Compaction
Mark & Sweep may leave fragmented memory:

16. Compaction Mark & Sweep may leave fragmented memory:
Allocations must be contiguous
Allocation might fail even with enough space

17. Compaction
Compaction : copy allocations so they are packed tightly:

18. Compaction Compaction : copy allocations so they are packed tightly:
Expensive
Need to “freeze” user code while addresses updated

19. Time
Memory tends to be short lived or long lived:

20. Time Advanced GC uses different pools for:
Young allocations – checked frequently
Old allocatins – checked less frequently

21. Garbage Collection Pros Cons No need to worry about deleting memory
System decides when to schedule cleanup work
Less predictable lifespan for objects

22. Smart Pointers C++11 brought smart pointers
Pointers do reference counting
Memory released when last reference is released

23. Shared Ptr shared_ptr : counts number sharing the object
When shared_ptr leaves scope, count--
Memory deleted when count == 0

24. Issue An object can be garbage without having a ref count of 0
Circular references

25. Weak Ptr weak_ptr : Pointer that will not keep object alive
Can not be used directly
Use to ask for a real shared ptr when needed
Used to avoid cycles of shared_ptr

26. Demo Students track classes with shared ptr
Classes track students with weak ptr

27. Demo
Student1 destroyed…

28. Demo
Student1 destroyed…
Course 1 ref count now 0. It is destroyed.

29. Demo
Student2 destroyed…

30. Demo Student2 destroyed… Both classes still have ref count of 1
Class 2 needs to check weak pointer to learn student2 is gone

31. Unique Ptr unique_ptr : unshared pointer Can't copy can only move
Deletes memory when pointer leaves scope

32. Smart Pointers Smart pointers Avoid manually deciding when to delete
Give us a language to think about relative lifespan
Shared : target will outlive this object
Weak : target may not outlive this object
Unique : no one else should have this - same lifespan
Still require careful reasoning

33. Swift Can pick: Manual release Garbage collection
ARC : Automatic Reference Counting
Like shared_ptrs and weak_ptrs