The document discusses Swift memory management and ARC. It explains that Swift uses reference counting, where objects remain in memory as long as their retain count is above zero. With ARC, memory management calls like retain and release are inserted by the compiler based on strong, weak and unowned references. While reference counting works automatically with ARC, some issues like retain cycles cannot be detected as they can with tracing garbage collectors used in other languages.

2. MEMORY MANAGEMENT
ON IOS

3. AGENDA
Reference Count Based Memory Management
Manual Reference Counting
Automatic Reference Counting (ARC)
ARC vs. Tracing Garbage Collectors
Gotchas

4. REFERENCE COUNT BASED
MEMORY MANAGEMENT

5. WHY DO WE NEED MEMORY
MANAGEMENT?
func createPerson() {
var p = Person()
}
main
createPerson()
Person
Stack Heap

6. WHY DO WE NEED MEMORY MANAGEMENT?
class Business {
var owner: Person
init() {
self.owner = Person()
}
}
1
1
2
…
…
Person
Stack Heap
Business
ViewController
Reference Count

7. MANUAL REFERENCE
COUNTING

8. MANUAL REFERENCE COUNTING
Objects are held in memory as long as they have a retain
count that is larger than 0

9. MANUAL REFERENCE COUNTING
Retain count of an object is mainly determined by calls to three
different methods: retain, release, autorelease
Additionally objects you create have a retain count of 1 - in Obj-
C this is indicated by calling any method named “alloc”, “new”,
“copy”, or “mutableCopy”

10. MANUAL REFERENCE COUNTING
- (void)createPerson {
Person *person = [[[Person alloc] init] autorelease];
return person;
}
+1 -1

11. MANUAL REFERENCE COUNTING
@interface Business : NSObject
@property (nonatomic, strong) Person *name;
@end
+1 -1- (void)createOwner {
self.owner = [[[Person alloc] init] autorelease];
}
+1
- (void)freeOwner {
self.owner = nil;
}
-1

12. AUTOMATIC REFERENCE
COUNTING (ARC)

13. AUTOMATIC REFERENCE
COUNTING (ARC)
No manual calls to retain, release, autorelease
anymore
Memory Management calls are inserted at compile time
Think in strong, weak and unowned references

14. AUTOMATIC REFERENCE
COUNTING
class Business {
var owner: Person
weak var building: Building?
init() {
self.owner = Person()
self.building = Building()
}
}
+1
+0

15. ARC VS. TRACING GARBAGE
COLLECTORS

16. ARC VS. TRACING GARBAGE
COLLECTORS
Tracing Garage Collectors are used in many higher level languages
such as C#, Java and Ruby (Python uses reference counts)

17. ARC VS. TRACING GARBAGE
COLLECTORS
Tracing GCs collect unreferenced objects after certain time periods at
runtime, typically work in two phases:
1. Mark all objects that are reachable from a root object
2. Delete all objects that are not reachable from a root object

18. GOTCHAS

19. GOTCHAS
Pure reference counting garbage collection mechanisms
cannot detect retain cycles!
Retain cycles occur when multiple objects reference each
other strongly, but aren’t strongly referenced by any root
object

20. GOTCHAS
Retain cycles created by the usage of closures:
class UserViewController: UIViewController {
var callback: UserDetailsCallback?
override func viewDidAppear(animated: Bool) {
callback = { user in
self.showUser(user)
}
}
func showUser(user: User?) {
//...
}
}
UserViewController
UserDetailsCallback+1
+1

21. GOTCHAS
Fix retain cycles using weak/unowned:
class UserViewController: UIViewController {
var callback: UserDetailsCallback?
override func viewDidAppear(animated: Bool) {
callback = { [unowned self] user in
self.showUser(user)
}
}
func showUser(user: User?) {
//...
}
}
UserViewController
UserDetailsCallback+1
+0

22. GOTCHAS
Retain cycles created by the usage of strong delegates:
protocol UserViewDelegate {}
class UserView {
var delegate: UserViewDelegate?
}
class UserViewController: UIViewController {
var userView: UserView = UserView()
func viewDidLoad() {
super.viewDidLoad()
userView.delegate = self
}
}
UserViewController
UserView+1
+1

23. GOTCHAS
Fix using a weak reference to the delegate:
protocol UserViewDelegate {}
class UserView {
weak var delegate: UserViewDelegate?
}
class UserViewController: UIViewController {
var userView: UserView = UserView()
func viewDidLoad() {
super.viewDidLoad()
userView.delegate = self
}
}
UserViewController
UserView+1
+0

24. SUMMARY

25. SUMMARY
Swift’s memory management model is based on reference
counting
With ARC reference counting works semi-automatically, retain
and release calls are inferred from memory management
specifiers (strong, weak, unowned)
Some types of memory issues that can be detected by tracing
GCs cannot be detected by reference counting, e.g. retain
cycles

26. ADDITIONAL RESOURCES

27. ADDITIONAL RESOURCES
Apple: Advanced Memory Management
Programming Guide
iOS Memory Management Using Autorelease
Wikipedia: Tracing Garbage Collectors