automatic reference counting
Post on 21-Oct-2014
1.962 views
DESCRIPTION
Slides from Automatic Reference Counting by Giuseppe Arici @ Pragma NightTRANSCRIPT
Pragma Night @ Talent Garden
Automatic Reference Counting
Giuseppe Arici
Pragma Night
Memory Management
• Manual Reference Counting
• Higher level abstraction than malloc / free
• Straightforward approach, but must adhere to conventions and rules
• Garbage Collection
• Only available for OS X 10.5+, but depracated from 10.8+
• Not available on iOS due to performance concerns
• Automatic Reference Counting (ARC)
• Makes memory management the job of the compiler (and runtime)
• Available for: partially iOS 4+ or OS X 10.6+ / fully iOS 5+ or OS X 10.7+
Pragma Night
Manual Reference Counting
Reference Counting
Pragma Night
Manual Reference Counting
retain
2
alloc
1
release
1
release
0
(Only) Objective-C objects are reference counted:
• Objects start with retain count of 1 when created
• Increased with retain
• Decreased with release, autorelease
• When count equals 0, runtime invokes dealloc
dealloc
Pragma Night
Objects you createFor objects you create with [[SomeClass alloc] init] or [myInstance copy] (without autoreleasing):
• Retain should not need to be called
• Release when you are done using it in the {code block}
- (void)someMethod { NSObject *localObject = [[NSObject alloc] init]; _instanceArray = [[NSArray alloc] initWithObjects:localObject, nil]; [localObject release];}
- (void)dealloc { [_instanceVariable release]; [super dealloc];}
Pragma Night
Objects you don’t createFor objects you don’t create (e.g. get from methods):
• Retain only when saving to instance (or static) variable
• Release only if you retained it by saving it (as in above case)
- (void)someMethod { id localObject = [anArray objectAtIndex:0]; _instanceVariable = [localObject retain];}
- (void)dealloc { [_instanceVariable release]; [super dealloc];}
Pragma Night
AutoreleaseWhat if you create an object and you are returning it from a method, how would you be able to release it?
- (NSArray *)objects { NSArray *localArray = [[NSArray alloc] init]; return [localArray autorelease];}
- (NSArray *)objects { NSArray *localArray = [[NSArray alloc] init]; return [localArray release];}
- (NSArray *)objects { NSArray *localArray = [[NSArray alloc] init]; return localArray;}
✇Leak !
☠Crash !
☺Enjoy !
Pragma Night
Autorelease
• Instead of explicitly releasing something, you mark it for a later release
• An object called autorelease pool manages a set of objects to release when the pool is released
• Add an object to the release pool by calling autorelease
@autoreleasepool { // code goes here}
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];// code goes here[pool release];
Pragma Night
Autorelease
• Autorelease is NOT a Garbage Collector ! It is deterministic ⌚
• Objects returned from methods are understood to be autoreleased if name is not in implicit retained set (alloc/new/copy/mutableCopy/init)
• If you spawn your own thread, you’ll have to create your own NSAutoreleasePool
• Stack based: autorelease pools can be nested
Friday Q&A 2011-09-02: Let's Build NSAutoreleasePoolhttp://www.mikeash.com/pyblog/friday-qa-2011-09-02-lets-build-nsautoreleasepool.html
Pragma Night
The Memory Management Rule
Everything that increases the retain count with alloc, [mutable]copy[WithZone:], new or retain is in charge of the corresponding [auto]release.
From C++ to Objective-Chttp://pierre.chachatelier.fr/programmation/objective-c.php
Pragma Night
Automatic Reference Counting
“Automatic Reference Counting (ARC) in Objective-C makes memory management the job of the compiler. By enabling ARC with the new Apple LLVM compiler, you will never need to type retain or release again, dramatically simplifying the development process, while reducing crashes and memory leaks. The compiler has a complete understanding of your objects, and releases each object the instant it is no longer used, so apps run as fast as ever, with predictable, smooth performance.”
(Apple, “iOS 5 for developers” – http://developer.apple.com/technologies/ios5)
Pragma Night
Automatic Reference Counting
• The Rule is still valid, but it is managed by the compiler
• No more retain, release, autorelease nor dealloc
• New lifetime qualifiers for objects, which includes zeroing weak references (only available on iOS 5+ & OS X 10.7+)
• Apple provides a migration tool which is build into Xcode
Pragma Night
ARC Settings: Project | File
Pragma Night
Requirements
• iOS 5+ & OS X 10.7+ Full Support :)
• iOS 4 & OS X 10.6 (64-bit) No Runtime :(
Pragma Night
How it works !?
ARC consists of 2 main components
Frontend Compiler Optimizer
Pragma Night
• For every local variable inserts retain and [auto]release appropriately in the block scope { }
• For every owned instance variable inserts release appropriately in the dealloc method
• Call the [super dealloc] in dealloc method
• Generates errors when a variable ownership is not set correctly
ARC Frontend Compiler
Pragma Night
Method Family / Ownership
Method Name Family Object Ownership Action
alloc/new/copy/mutableCopy/init Create and have ownership of it
retain Take ownership of it
release Relinquish it
dealloc Dispose of it
Everything Else No ownership !
Method Name Family Object Ownership Action
alloc/new/copy/mutableCopy/init Create and have ownership of it
retain Take ownership of it
release Relinquish it
dealloc Dispose of it
Everything Else No ownership !
alloc/new/copy/mutableCopy/init ⇒ “ The Implicit Retained Set ”
Pragma Night
ARC Frontend Compiler 1/3
- (void)someMethod { Foo *foo = [[Foo alloc] init]; [foo bar]; [foo release];}
- (void)someMethod { Foo *foo = [[Foo alloc] init]; [foo bar];
}
- (void)someMethod { Foo *foo = [[Foo alloc] init]; [foo bar]; obj_release(foo);}
Pragma Night
ARC Frontend Compiler 2/3- (void)someMethod { Foo *localFoo = [self foo]; [localFoo bar];
self.foo = [Builder newFoo]; [localFoo bar];
}
- (void)someMethod { Foo *localFoo = objc_retain([self foo]); [localFoo bar];
self.foo = [Builder newFoo]; [localFoo bar]; objc_release(localFoo);}
☠Crash !
☺Enjoy !
Pragma Night
ARC Frontend Compiler 3/3
- (Foo *) foo{ return [[_foo retain] autorelease];}
- (Foo *) foo{ return _foo;}
- (Foo *) foo{ return objc_retainAutoreleaseReturnValue(_foo);}
Pragma Night
• Optimize the retain and release statements by removing them if they are inserted multiple times by the ARC Frontend Compiler
• Ensures that performance is not affected by calling retain and release multiple times
ARC Optimizer
Pragma Night
ARC Optimizer 1/2
retainautoreleaseretainrelease
retain
releasestack
Pragma Night
ARC Optimizer 1/2
retain
releasestack
Pragma Night
ARC Optimizer 2/2- (Foo *) foo{ return objc_retainAutoreleaseReturnValue(_foo);}
- (void)someMethod { Foo *f = objc_retainAutoreleasedReturnValue([self foo]); [f bar];
self.foo = [Builder newFoo]; [f bar]; objc_release(f);}
called method
caller method
Autorelease Pool
Pragma Night
Variable Ownership Qualifiers
• __strong (default)
• __weak
• __unsafe_unretained
• __autoreleasing
Only For Object Type Variables !( id | AnyClass : NSObject )
Pragma Night
Retain Cycles 1/5
Child
View
Parent
Controller
__strong
+1_view
__strong
as View Delegate
+1_delegate
Pragma Night
Retain Cycles 2/5
Child
View
Parent
Controller
__strong
+1_view
__unsafe_unretained
as View Delegate
=_delegate
Pragma Night
Retain Cycles 3/5
Child
View
Parent
Controller
__strong
+1_view
__weak
as View Delegate
=_delegate
Pragma Night
release
Retain Cycles 4/5
Child
View
Parent
Controller
=☠_view
__weak
as View Delegate
_delegate
dealloc
☺nil
New with ARC iniOS 5+ & OS X 10.7+
_view
_delegate
Pragma Night
Retain Cycles 5/5
Pragma Night
__strong
/* not-ARC */{ id obj1 = [[NSObject alloc] init]; [obj1 release];}
/* ARC */{ id __strong obj1 = [[NSObject alloc] init]; id obj2 = [[NSObject alloc] init];}
• Strong reference for the object
• Default for ‘id’ and Object Type Variables !
Pragma Night
__weak
/* not-ARC */{ id obj1 = [[NSObject alloc] init]; id obj2 = obj1; [obj1 release];}
/* ARC */{ id __strong obj1 = [[NSObject alloc] init]; id __weak obj2 = obj1;}
• No ownership of the object
• When discarded, the variable is assigned to nil
Pragma Night
__unsafe_unretained/* ARC */{ id __unsafe_unretained obj = [[NSObject alloc] init];}
• UNSAFE !
• You must take care of the variables manually
• __weak only for iOS 5+ / OSX 10.7+
Assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]
Pragma Night
__autoreleasing
- (BOOL) performWithError:(NSError **)error;
- (BOOL) perfomrWithError:(NSError * __autoreleasing *)error;
@autoreleasepool{ id __strong obj = [NSMutableArray array];}
• Pointer to ‘id’ or to ‘Object Type Variables Pointer’ is qualified with __autoreleasing as default
Pragma Night
Variables Initialization
/* not-ARC */id __strong obj1 = nil;id __weak obj2 = nil;id __unsafe_unretained obj3;id __autoreleasing obj4 = nil;
/* ARC */id __strong obj1;id __weak obj2;id __unsafe_unretained obj3;id __autoreleasing obj4;
• Any variables that are qualified with __strong, __weak and __autoreleasing are initialized with nil
☠Crash !
Pragma Night
Property
* Note: new copied object is assigned
*
Object Property Modifier Variable Ownership Qualifier
assign __unsafe_unretained
unsafe_unretained __unsafe_unretained
weak __weak
retain __strong
strong __strong
copy __strong
Pragma Night
Property
• Same ownership rules as instance variables
• Manually declared instance variables has to have the same ownership qualifier as the property
• Copy: copies the object by using copyWithZone
Pragma Night
Coding With ARC Rules
What is forbidden ?
What can be done but with care ?
What is mandatory ?
Pragma Night
Rule 01/12
• Forget about using retain, release, retainCount and autorelease
{ id obj1 = [[NSObject alloc] init]; /* ... */ [obj1 release];}
error: ARC forbids explicit message send of 'release' [obj release];
Pragma Night
Rule 02/12
• Forget about using NSAllocateObject, NSDeallocateObject, NSZone & Co.
/* NSObject.h */
/***********!Object Allocation / Deallocation!! *******/ FOUNDATION_EXPORT id NSAllocateObject(Class, NSUInteger, NSZone *) NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
error: 'NSAllocateObject' is unavailable: not available in automatic reference counting mode
Pragma Night
Rule 03/12
• Forget about using NSAutoreleasePool Use @autoreleasepool { ... } Instead
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
/* ... */
[pool drain]; // [pool release];
error: 'NSAutoreleasePool' is unavailable: not available in automatic reference counting mode
Pragma Night
Rule 04/12
• Forget about calling super dealloc explicitly
- (void) dealloc{ free(buffer); [super dealloc];}
error: ARC forbids explicit message send of 'dealloc' [super dealloc]; not available in automatic reference counting mode
Pragma Night
Rule 05/12
• Object Type Variables Cannot Be Members of struct or union in C
struct Data{ NSMutableArray *array;};
error: ARC forbids Objective-C objs in structs or unions NSMutableArray *array;
Pragma Night
Rule 06/12
• Exceptions use must be exceptional
• For performance purpose, ARC code leaks on exceptions
• In Obj-C ARC is not exception-safe for normal releases by default
• -fobjc-arc-exceptions / -fno-objc-arc-exceptions: enable / disable
• In Obj-C++ -fobjc-arc-exceptions is enabled by default
Pragma Night
Rule 07/12
• IBOutlet must be declared as weak
• Outlets should be defined as declared properties
• Outlets should generally be weak
• Top-level objects (or, in iOS, a storyboard scene) should be strong
Resource Programming Guide
Pragma Night
Rule 08/12
• Be careful with performSelector
#pragma clang diagnostic push#pragma clang diagnostic ignored \ "-Warc-performSelector-leaks" [self performSelector:@selector(someMethod)]; #pragma clang diagnostic pop
Pragma Night
Rule 09/12
• Follow the naming rule for methods relatedto object creation: implicit retained set
• If begins { alloc/new/copy/mutableCopy }, the caller has ownership
• If begins { init }, the method has to:
• be an instance method
• return an object of type ‘id’ or an object of type of its [super|sub]class
• return an object not registered in autoreleasepool: the caller has ownership
- (id)init...;
* A special case: “ + (void) initialize ”
*
Pragma Night
False Positive
-(NSString*) copyRightString NS_RETURNS_NOT_RETAINED;
-(NSString*) copyRightString;
• NS_RETURNS_RETAINED
• NS_RETURNS_NOT_RETAINED
This macro is ONLY to be used in exceptional circumstances, not to annotate functions which conform to the Cocoa naming rules.
Pragma Night
Rule 10/12
• Switch cases must be wrapped in scope with { ... }
switch (value){ case 0: { NSObject *obj= [[NSObject alloc] init]; NSLog(@"obj for value 0: %@", obj); } break;}
Pragma Night
Rule 11/12
• The old style singleton which redefines retain and release is not ARC compatible
• Singletons should be redefined with dispatch_once
static Foo *sharedInstance;
+ (id)sharedInstance { static dispatch_once_t predicate; dispatch_once(&predicate, ^{ sharedInstance = [[Foo alloc] init]; }); return sharedInstance;}
Pragma Night
Rule 12/12
• 'id' and 'void *' Have to Be Cast Explicitly
id object = [[NSObject alloc] init];void *pointer = object;
Error: implicit conversion of a non-Objective-C pointer type 'void *' to 'id' is disallowed with ARC
Pragma Night
( _bridge cast )
id object1 = [[NSObject alloc] init];void *pointer = (__bridge void *)object1;id object2 = (__bridge id)pointer;
• More dangerous than an __unsafe_unretained qualified variable !
• You have to manage ownership of the object yourself carefully or it crashes
Pragma Night
( __bridge_retained cast )
/* not-ARC */id object = [[NSObject alloc] init];void *pointer = object;[(id)pointer retain];
/* ARC */id object = [[NSObject alloc] init];void *pointer = (__bridge_retained void *)object;
• From ARC to Core Foundation
• __bridge_retained cast will retain the object just after the assignment is done
Pragma Night
( __bridge_transfer cast )
/* not-ARC */id object = (id)pointer;[object retain];[(id)pointer release];
/* ARC */void *pointer = &bytes;id object = (__bridge_transfer id)pointer;
• From Core Foundation to ARC
• __bridge_transfer cast will release the object just after the assignment is done
Pragma Night
Toll-Free Bridging
/* NSObject.h */
// After using a CFBridgingRetain on an NSObject, the caller // must take responsibility for calling CFRelease at an // appropriate time
NS_INLINE CF_RETURNS_RETAINED CFTypeRef CFBridgingRetain(id X) { return (__bridge_retained CFTypeRef)X;}
NS_INLINE id CFBridgingRelease(CFTypeRef CF_CONSUMED X){ return (__bridge_transfer id)X;}
Pragma Night
ARC MACRO
// define some LLVM3 macros if the code is// compiled with a different compiler (ie LLVMGCC42)#ifndef __has_ feature#define __has_feature(x) 0#endif
#ifndef __has_extension// Compatibility with pre-3.0 compilers#define __has_extension __has_feature#endif
#if __has_feature(objc_arc) && __clang_major__ >= 3#define ARC_ENABLED 1#endif
Check @ compile-time if ARC is enabled
Pragma Night
tl;dr ⇒ What Is ARC ?
• Automatic memory management of Obj-C objects
• Compiler obeys and enforces existing conventions
• Full interoperability with manual retain and release
• New runtime features
• Weak pointers
• Advanced performance optimizations
Pragma Night
tl;dr ⇒ What ARC Is NOT ?
• No new runtime memory model
• No automation for malloc/free, CF, etc.
• No garbage collector
• No heap scans
• No whole app pauses
• No non-deterministic releases
Pragma Night
ARC References
• Clang: Automatic Reference Counting documentation
• Apple: Transitioning to ARC Release Notes
• Apple: Xcode New Features User Guide: Automatic Reference Counting
• WWDC 2011 – Session 323 – Introducing Automatic Reference Counting
• WWDC 2012 – Session 406/416 – Adopting Automatic Reference Counting
• Mike Ash: Friday Q&A about Automatic Reference Counting
• Mike Ash: Zeroing weak references without ARC
Pragma Night
ARC Books