blocks and gcd(grand central dispatch)
DESCRIPTION
How to use Block operations and use of GCDTRANSCRIPT
Pragma Night @ Talent Garden
Blocksand
Grand Central Dispatch
Matteo Battaglio
giovedì 7 febbraio 13
Pragma Night
Blocks
giovedì 7 febbraio 13
Pragma Night
What are Blocks?
• an extension to the C language and its derivatives Objective-C and C++, introduced by Apple
• available in iOS SDK since version 4.0
• already used by plenty of iOS frameworks’ APIs
Blocks are:
giovedì 7 febbraio 13
Pragma Night
Benefits
• more functional style of coding
• less boilerplate code
• more readable code
• simplify event-driven scenarios (i.e. callbacks)
• simplify multi-threading
giovedì 7 febbraio 13
Pragma Night
Definition
• ‘block’ is the name Objective-C gives to the concept of closure, that is:
• a pointer to a function
• a copy of some of the local variables of its higher-order function
giovedì 7 febbraio 13
Pragma Night
Syntax
int multiplier = 7;
int (^myBlock)(int) = ^(int num) { return num * multiplier; };
Declaration of the variable ‘myBlock’.
The ‘^’ tells that its type is a block.
Return type Parameter list
Definition of the variable ‘myBlock’, using a block literal.
The parameter is named ‘num’.
Body of the block.
giovedì 7 febbraio 13
Pragma Night
Key features
• allow code to be passed around for later execution
• access to the local variables of the function they were declared in
• mantain a state among calls
giovedì 7 febbraio 13
Pragma Night
Code example #1
int multiplier = 7; // Declaring a block and assigning it to the variable ‘myBlock’
int (^myBlock)(int) = ^(int num) { return num * multiplier; };
// Calling the block
printf(myBlock(3)); // prints '21'
Calling a block in no different than calling a function
giovedì 7 febbraio 13
Pragma Night
Code example #2
// Inline use of a block literal (as an actual parameter of a function)
char *myCharacters[3] = { "TomJohn", "George", "Charles Condomine" };
qsort_b(myCharacters, 3, sizeof(char *), ^(const void *l, const void *r) { char *left = *(char **)l; char *right = *(char **)r; return strncmp(left, right, 1);});
// myCharacters is now { "Charles Condomine", "George", "TomJohn" }
qsort_b() will internally call the block many times, in order to compare each pair of cells in the array
giovedì 7 febbraio 13
Pragma Night
Code example #3
// Declaring a function that takes a block as parameter
void myFunction(int (^aBlock)(void *, void *));
// Declaring a function that returns a block
void (^myFunction(int a, int b))(double, double);
Function name Function parameters The function’s return type is a block with signaturevoid (^)(double, double)
giovedì 7 febbraio 13
Pragma Night
Code example #4
// Defining a custom name for our block type to improve code style
typedef void (^MyBlockType)(double, double);
// Variable and function declarations now look much more readable
MyBlockType myBlock = ^(double a, double b) { printf("hey!"); };
MyBlockType myFunction(int a, int b, MyBlockType aBlock);
giovedì 7 febbraio 13
Pragma Night
Variables caveats
• non-local variables in blocks are constant and read-only
Trying to modify ‘i’ from inside the block results in a compilation error.
• in order to make them ‘live’ and writable the __block type specifier must be added to their declaration
giovedì 7 febbraio 13
Pragma Night
__block
• what __block does is:
• pass the variable by reference - rather than by value - to the block
• create a strong (as opposed to weak) reference to that variable
int myFunction() { __block int i = 0; void (^myBlock)(void) = ^{ i++; printf("i has the value %d", i); // prints 'i has the value 1' }; }
giovedì 7 febbraio 13
Pragma Night
State representation
• blocks can use variables marked with __block to keep a state among calls
int myFunction() { __block int i = 0; void (^myBlock)(void) = ^{ i++; printf("i has the value %d", i); };
myBlock(); // prints 'i has the value 1'
myBlock(); // prints 'i has the value 2' }
giovedì 7 febbraio 13
Pragma Night
Information hiding
int array[] = {4, 5, 2, 6, 1}; qsort_b(array, 5, sizeof(int), ^(void) { __block int sum = 0; return ^(const void *a, const void *b) { sum += (int)a; return a - b; };}());
The outer block defines a local variable that is used inside the inner block to mantain a state: this way we are keeping the sum
variable hidden to the rest of the program
The inner block is what gets passed to the qsort_b() function
These parentheses tell us that the outer block is executed, and not passed to qsort_b.
giovedì 7 febbraio 13
Pragma Night
__block implications
• variables marked with __block are shared between their lexical scope and all blocks and block copies declared or created within that scope
• multiple blocks can simultaneously use a shared variable
• when a block is copied (i.e. it is moved from the stack to the heap), they survive the destruction of their stack frame
giovedì 7 febbraio 13
Pragma Night
Memory concerns
• a block is allowed to access self
• self is passed as a strong reference
• this could lead to a ‘retain cicle’
• trick: define a __weak reference to self int myFunction() { __weak MyObject weakSelf = self; void (^myBlock)(void) = ^{ [weakSelf someMethod]; } }
giovedì 7 febbraio 13
Pragma Night
Common scenarios in the SDK
NSArray *array = [NSArray arrayWithObjects:@"One", @"Two", @"Three", @“Four”, nil];
[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { NSLog(@"array[%d] = %@", idx, obj); }];
[array enumerateObjectsWithOptions: NSEnumerationConcurrent usingBlock: ^(id obj, NSUInteger idx, BOOL *stop) { NSLog(@"array[%d] = %@", idx, obj); } ];
It substitutes the for loop.Now the collections can enumerate themselves.
Collection enumeration
Setting *stop to YES inside the block will stop the enumeration
Making an enumeration concurrent is a matter of adding an option!
giovedì 7 febbraio 13
Pragma Night
Common scenarios in the SDK
- (void)animateView:(UIView*)view { CGRect cacheFrame = [view frame]; [UIView animateWithDuration:1.5 animations: ^{ CGRect newFrame = [view frame]; newFrame.origin.y = newFrame.origin.y + 250.0; [view setFrame:newFrame]; [view setAlpha:0.5]; } completion: ^(BOOL finished) { if (finished) { sleep(1); [view setFrame:cacheFrame]; [view setAlpha:1.0]; } }];}
View animations
giovedì 7 febbraio 13
Pragma Night
Common scenarios in the SDK
NSNotificationCenter *center = [NSNotificationCenter defaultCenter]; NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
[center addObserverForName:SomeNotificationName object:nil queue:mainQueue usingBlock:^(NSNotification *note) { NSLog(@"Notification received"); }];
Notification observers
giovedì 7 febbraio 13
Pragma Night
Common scenarios in the SDK
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperationWithBlock:^{ NSLog(@"This block is run in the operation"); }];
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{ NSLog(@"This block is run in the operation"); }];
[operation addExecutionBlock:^{ NSLog(@"NSBlockOperations can execute multiple blocks "); }];
[operation setCompletionBlock:^{ NSLog(@"This Code Runs Once The Operation Has Finished"); }];
Operations queues
Wraps the block inside a NSOperation
A single NSBlockOperation can execute multiple blocks concurrently
giovedì 7 febbraio 13
Pragma Night
Grand Central Dispatch
giovedì 7 febbraio 13
Pragma Night
What is Grand Central Dispatch?
• a set of language features and libraries to improve and simplify the act of writing concurrent code
• more efficient than threads
• implemented at all levels of APIs in iOS (BSD subsystem, CoreFoundation, Cocoa)
Grand Central Dispatch (GCD) is:
giovedì 7 febbraio 13
Pragma Night
Concept
• GCD is based on the Thread Pool pattern
• a (small) number of threads is created
• (possibly lots of) tasks are added to queues in order to be executed
• an algorithm handles the creation/destruction of threads, and the scheduling of tasks
giovedì 7 febbraio 13
Pragma Night
Implementation
• dispatch queues
• dispatch sources
• dispatch groups
• dispatch semaphores
giovedì 7 febbraio 13
Pragma Night
Dispatch queues• execute tasks always in a first-in, first-out order
• 2 types:
• serial queues (aka private dispatch queues)
• one and only one task running at a time
• the main dispatch queue is a peculiar one
• concurrent queues (aka global dispatch queues)
• tasks started in order but run concurrently
• four such queues, differing only by priority level, are made available by the os
giovedì 7 febbraio 13
Pragma Night
Serial queues
• one and only one task running at a time
• the main dispatch queue is serial
• tied to the main thread and application’s run loop
• interleaves queued tasks with other event sources
• often used as the key synchronization point for the application
giovedì 7 febbraio 13
Pragma Night
Creating serial queues
// Creating a serial dispatch queuedispatch_queue_t queue;queue = dispatch_queue_create("com.example.MyQueue", NULL);
// Getting the dispatch queue on which the currently executing block is runningdispatch_queue_t current_queue;current_queue = dispatch_get_current_queue();
// Getting the main dispatch queuedispatch_queue_t main_queue;main_queue = dispatch_get_main_queue();
giovedì 7 febbraio 13
Pragma Night
Concurrent queues
• tasks are started in order but run concurrently
• the system provides four concurrent queues
• they are global to the application
• they differ only by priority level
giovedì 7 febbraio 13
Pragma Night
Creating concurrent queues
// Getting one of the four global dispatch queuesdispatch_queue_t global_queue;global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// The four priority levels, ranked high to low, areDISPATCH_QUEUE_PRIORITY_HIGHDISPATCH_QUEUE_PRIORITY_DEFAULTDISPATCH_QUEUE_PRIORITY_LOWDISPATCH_QUEUE_PRIORITY_BACKGROUND
// Creating a concurrent dispatch queuedispatch_queue_t queue;queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_CONCURRENT);
giovedì 7 febbraio 13
Pragma Night
• dispatch_async(queue, block)
• submits a block for asynchronous execution on a dispatch queue and returns immediately
• dispatch_sync(queue, block)
• submits a block object for execution on a dispatch queue and waits until that block completes
Using queues
giovedì 7 febbraio 13
Pragma Night
• dispatch_after(when, queue, block)
• enqueue a block for execution at the specified time
• dispatch_apply(iterations, queue, block)
• submits a block to a dispatch queue for multiple invocations
• dispatch_once(queue, block)
• executes a block object once and only once for the lifetime of an application
Using queues
giovedì 7 febbraio 13
Pragma Night
Dispatch sources
• allow the client to register blocks or functions to execute asynchronously upon system events
• unlike manually-put tasks, they remain attached to their queue, and submit their associated task to it whenever the corresponding event occurs
• to prevent backlogging, they can coalesce events
• types of sources: signal, timer, descriptor, process, Mach port, custom
giovedì 7 febbraio 13
Pragma Night
Dispatch source exampledispatch_source_t CreateDispatchTimer(uint64_t interval, uint64_t leeway, dispatch_queue_t queue, dispatch_block_t block) { dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue); if (timer) { dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), interval, leeway); dispatch_source_set_event_handler(timer, block); dispatch_resume(timer); } return timer;}
void MyCreateTimer() { dispatch_source_t aTimer = CreateDispatchTimer(30ull * NSEC_PER_SEC, 1ull * NSEC_PER_SEC, dispatch_get_main_queue(), ^{ MyPeriodicTask(); }); // Store it somewhere for later use. if (aTimer) { MyStoreTimer(aTimer); }}
giovedì 7 febbraio 13
Pragma Night
Dispatch groups
• are objects that allow several tasks to be grouped for later joining.
• a task can be added to a queue as a member of a group, and then the client can use the group object to wait until all of the tasks in that group have completed
giovedì 7 febbraio 13
Pragma Night
Dispatch group example
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);dispatch_group_t group = dispatch_group_create(); // Add a task to the groupdispatch_group_async(group, queue, ^{ // Some asynchronous work}); //// Do some other work while the tasks execute...// // When you cannot make any more forward progress,// wait on the group to block the current thread.dispatch_group_wait(group, DISPATCH_TIME_FOREVER); // Release the group when it is no longer needed.dispatch_release(group);
giovedì 7 febbraio 13
Pragma Night
Dispatch semaphores
• useful for regulating the use of finite resources
// Example: limiting the number of file descriptors open concurrently
// Create the semaphore, specifying the initial pool size dispatch_semaphore_t fd_sema = dispatch_semaphore_create(getdtablesize() / 2); // Wait for a free file descriptor dispatch_semaphore_wait(fd_sema, DISPATCH_TIME_FOREVER); fd = open("/etc/services", O_RDONLY); // Release the file descriptor when done close(fd); dispatch_semaphore_signal(fd_sema);
giovedì 7 febbraio 13
Pragma Night
References
• WWDC 2011 - session 308:Blocks and Grand Central Dispatch in Practice
• Apple documentation
• Blocks Programming Topics
• Concurrency Programming Guide
• Grand Central Dispatch (GCD) Reference
• Book: Pro Multithreading and Memory Management for iOS and OS X: with ARC, Grand Central Dispatch, and Blocks
giovedì 7 febbraio 13
Pragma Night
Thank You!
giovedì 7 febbraio 13