NSMutableArray replaceObjectAtIndex:withObject Loop Leakage - ios

Question

I've edited the previous post with some working code for convenience.
The follow code (ARC'ed) seems to leak and will crash the sim or the device after running for a short period of time:
#define kROWS 100
#define kCols 34
void run();
static ViewController *instance;
#interface ViewController ()
#property (nonatomic, strong) NSMutableArray *nsBackColor;
#end
#implementation ViewController
- (void)viewDidLoad
{
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
self.nsBackColor = [NSMutableArray arrayWithCapacity:1];
instance = self;
// set up a '2D array'
for (int x = 0; x < kROWS; x++) {
[self.nsBackColor addObject:[NSMutableArray arrayWithCapacity:1]];
for (int y = 0; y < kCols; y++) {
[[self.nsBackColor objectAtIndex:x] addObject:[UIColor whiteColor]];
}
}
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
run();
});
}
- (void)plotColor:(UIColor *)color atX:(short)x andY:(short)y {
[[self.nsBackColor objectAtIndex:x] replaceObjectAtIndex:y withObject:color];
}
- (void)didReceiveMemoryWarning
{
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}
#end
void plot(short xLoc, short yLoc,
short backRed, short backGreen, short backBlue) {
#autoreleasepool {
[instance plotColor:[UIColor colorWithRed:((float)backRed/100)
green:((float)backGreen/100)
blue:((float)backBlue/100)
alpha:(float)1]
atX:xLoc andY:yLoc];
}
}
void run() {
short x = 0;
short y = 0;
short backRed = 0;
short backGreen = 0;
short backBlue = 0;
while (true) {
x++;
if (x >= kROWS) {
x = 0;
}
y++;
if (y >= kCols) {
y = 0;
}
backRed = arc4random() % 255;
backBlue = arc4random() % 255;
backGreen = arc4random() % 255;
plot(x, y, backRed, backGreen, backBlue);
usleep(1000);
}
}
If I let this run on the device or the simulator long enough (a couple minutes) I'll receive either an mmap malloc error (sim) or a memory warning (device) and crash.
Going through Instruments Allocations I can see +[UIColor colorWithRed:green:blue:alpha:] start to ballon until finally hitting the memory wall.
I can assign the UIColor to a property (directly or by doing a copy), say self.myColor = color, and there is no such leak.
I can do this too:
[[self.nsBackColor objectAtIndex:x] replaceObjectAtIndex:y withObject:[self description]];
and I get the same leak.
It seems to me that object replaced in the array (and yes, this did originally start as a 2D c array but I thought that was the issue) is forever lost and leaked and not properly released.
This would be the Instruments->Allocations after running for a short period of time:
Any help would be much appreciated and more information can be provided.

Answer 1

What is happening is that you are creating an autorelease pool at every iteration.
So the following line runs every time with a new autorelease pool:
[[self.nsBackColor objectAtIndex:x] replaceObjectAtIndex:y withObject:color];
Therefore color increases its reference count within the local pool by one, while [[self.nsBackColor objectAtIndex:x] objectAtIndex:y] decreases its reference count within the local pool by one. But here's the catch: That item was color in the previous iteration, which had its reference count managed by the previous pool that you drained/released earlier.
So what should have happened is as the previous pool was released in the previous iteration, that object was released. Its reference count was 2 (one for [UIColor colorWith...], one for adding to the array), so it should have received 2 release messages as soon as the pool was drained, and the pointer in [[self.nsBackColor objectAtIndex:x] objectAtIndex:y] should be left dangling until you replace it in the current iteration with a pointer to color.
Clearly that's not happening exactly the way it's supposed to be, or the way I understand it. However, the #autoreleasepool {} directive is clearly misplaced. It should be around the while (true) loop, or removed altogether in favor of the thread's pool.