For-loop optimization in Objective-C - objective-c

Question

Just looking for some simple advice on how best to optimize a for loop (in terms of memory usage) in Obj-C and ARC taking this non-optimized arbitrary code as:
NSMutableArray *array = [NSMutableArray array];
for (NSDictionary *dict in NSArray *arrayOfDicts) {
NSString *first = [dict valueForKeyPath:#"object.first"];
NSString *second = [dict valueForKeyPath:#"object.second"];
NSString *third = [dict valueForKeyPath:#"object.third"];
[array addObject:#[first, second, third]];
}
Which of these is better/right in practice (assuming many loops so it might matter)
1) Declare once, copy into array.
NSMutableArray *array = [NSMutableArray array];
NSString *first, *second, *third;
for (NSDictionary *dict in NSArray *arrayOfDicts) {
first = [dict valueForKeyPath:#"object.first"];
second = [dict valueForKeyPath:#"object.second"];
third = [dict valueForKeyPath:#"object.third"];
[array addObject:#[[first copy], [second copy], [third copy]]];
first, second, third = nil;
}
2) Autoreleasepool
NSMutableArray *array = [NSMutableArray array];
for (NSDictionary *dict in NSArray *arrayOfDicts) {
#autoreleasepool {
NSString *first = [dict valueForKeyPath:#"object.first"];
NSString *second = [dict valueForKeyPath:#"object.second"];
NSString *third = [dict valueForKeyPath:#"object.third"];
[array addObject:#[first, second, third]];
}
}
3) Something else?

Answer 1

first, second and third survive beyond the loop in all situations regardless because they're in dict. The array of #[first, second, third] survives regardless because it has been added to the array.
Hence there's going to be very limited difference between the three. valueForKeyPath: doesn't produce a copy so all you're talking about is (i) storage within the retain count table*; and (ii) storage within the autorelease pool.
(i) is not just negligible but so internal to the current implementation of the runtime that there's no point relying on it. (ii) is also negligible but explicitly required by the spec.
Technically the #autoreleasepool will probably be slightly more compact (depending on the total size of an empty pool versus the size required to add an object to the pool versus the length of your array) but I wouldn't obsess over it.
There's absolutely no difference between the first two options. How local the storage is doesn't affect ARC — even without relying on exact ARC implementation details, you're reassigning at the top of the next iteration regardless.
(* retain counts aren't stored until they're greater than 1 as 1 is a very common value and is implied by an object existing at all; hence they go in a separate table and not with the object)
2018 edit: the 64-bit runtime actually stores retain counts greater than 1 but less than a very big number in part of the isa pointer, since the whole 64-bit range isn't currently needed. And if it ever is, they can just move the retain count out again. The very big number was 2^19+1 in the original 64-bit runtime, but it's opaquely sized so may have changed since. So additional retains essentially never increase memory footprint on modern devices.

Answer 2

The biggest speed improvement by far while be to remove the free calls to valueForKeyPath.
valueForKeyPath is given a string argument, for example object.first. It then has to analyze the string: Find the dot in the middle, figure out that the receiver is a dictionary, that "object" doesn't start with an # character so it corresponds to objectForKey and so on. All that three times. Instead
for (NSDictionary *dict in NSArray *arrayOfDicts) {
SomeObject* someObject = [dict objectForKey:#"object"];
[array addObject:#[[someObject.first copy],
[someObject.second copy],
[someObject.third copy]]];
}
It's up to you to decide whether copy is necessary. Objects often have "copy" properties so first, second, third might be copies already.