1. Automating Memory Management

2. Dumb Pointers • Pointers Necessary • Dynamic memory • Sharing memory

3. Dumb Pointers • Pointers Necessary • 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

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

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

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

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

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 • No need to worry about deleting memory • Cons • 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 trackclasses withshared ptr • Classes trackstudents withweak ptr

27. Demo • Student1destroyed…

28. Demo • Student1destroyed… • Course 1 refcount now 0.It is destroyed.

29. Demo • Student2destroyed…

30. Demo • Student2destroyed… • Both classesstill have refcount of 1 • Class 2 needsto check weakpointer to learnstudent2 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