Strange performance issue with nested (for-)loops - ios

Question

Using Instruments to look for bottlenecks in my code I stumbled upon some weird observation:
I am parsing two csv files; one contains about 3000 customers, the other about 8000 orders.
After that I'm iterating over the two arrays containing the customers and orders to detect relationships between each other. That way I not only find the corresponding orders for each customer but also determine their last orders; according to that date they are categorized.
At the beginning neither of the two arrays were sorted, so for every customer i went through ALL remaining orders, which took like 3-4 secs. Then I came up with the idea to sort both arrays using the customer ids. Now I know that the first orders of the orders-array correspond to the first customer. As soon I got a different customer id in my order, I know, that this has to be the next customer's order. so I remove the orders that I already processed and do the same for the next customer. I already have my next tweaking idea (just using the index of a block enumeration and keep track of that index. That way I don't have to remove any entries. Maybe I some more performance boost. But currently I have another issue, which I explain after the following code:
- (void) determineLastOrders {
for (Kunde * kunde in _kundenArray) {
[self determineLastOrder:kunde];
}
}
- (void) determineLastOrder: (Kunde*)kunde {
NSMutableArray *bestellungenToRemove = [[NSMutableArray alloc] init];
/* go through all (remaining) orders (after the loop the matching will be removed) and determine the next ones to remove */
for (Bestellung * bestellung in _bestellungenMutArr) {
if ([[bestellung bestKdNr] isEqualToString:kunde.kdnr]) {
if ( kunde.lastOrder == nil) {
kunde.lastOrder = _orangeDate; //"init"
}
else if ([kunde.lastOrder compare:[bestellung bestDatum]] == NSOrderedAscending) {
kunde.lastOrder = [bestellung bestDatum];
}
[bestellungenToRemove addObject:bestellung];
}
else {
//as all orders are ordered by the customer id we can abort iteration
//after we went past the current id
break;
}
}
// after the iteration we can safely remove the instances from the array
// this is quite efficient as due to the order of the orders we ALWAYS remove from
// the beginning of the array -> http://ridiculousfish.com/blog/posts/array.html
[_bestellungenMutArr removeObjectsInArray: bestellungenToRemove];
if ([kunde.lastOrder compare:_orangeDate] == NSOrderedDescending) {
[kunde setDotPath: #"green.png"];
}
else if (kunde.lastOrder == nil) {
[kunde setDotPath: #"red.png"];
}
else {
[kunde setDotPath: #"orange.png"];
}
}
I found out that the block of the 2 functions roughly takes about 400ms. My next thought was, that I might get some small performance gain, if I don't use 2 functions and thus save about 3000 function calls.
So I kicked out the 1st function and simply put my for loop around the contents of the 2nd function. That time it took roughly about 10 times longer?!? Why could that be?
Thanks
EDIT1:
The slower code version with nested loop:
- (void) determineLastOrders
{
NSMutableArray *bestellungenToRemove = [[NSMutableArray alloc] init];
for (Kunde * kunde in _kundenArray)
{
/* go through all (remaining) orders (after the loop the matching will be removed) and determine the next ones to remove */
for (Bestellung * bestellung in _bestellungenMutArr)
{
if ([[bestellung bestKdNr] isEqualToString:kunde.kdnr])
{
if ( kunde.lastOrder == nil)
{
kunde.lastOrder = _orangeDate; //"init"
}
else if ([kunde.lastOrder compare:[bestellung bestDatum]] == NSOrderedAscending)
{
kunde.lastOrder = [bestellung bestDatum];
}
//As this Bestellung already has had a date comparison (equal by kdnr)
//we won't need to visit it again by our next customer
[bestellungenToRemove addObject:bestellung];
}
else
{ //as all orders are ordered by the customer id we can abort iteration
//after we went past the current id
break;
}
}
//after the iteration we can safely remove the instances from the array
//this is quite efficient as due to the order of the orders we ALWAYS remove from
//the beginning of the array -> http://ridiculousfish.com/blog/posts/array.html
[_bestellungenMutArr removeObjectsInArray: bestellungenToRemove];
if ([kunde.lastOrder compare:_orangeDate] == NSOrderedDescending)
{
[kunde setDotPath: #"green.png"];
}
else if (kunde.lastOrder == nil)
{
[kunde setDotPath: #"red.png"];
}
else
{
[kunde setDotPath: #"orange.png"];
}
}
}

Answer 1

In the version with just a single function, you've left the initialization of the bestellungenToRemove mutable array outside the outer loop. This means you don't get a new one for each iteration of the outer loop, as you do in the two-function version.
Since that array gets larger each time through, the removeObjects: call takes longer and longer as that array grows.
So, move it back into the outer loop and you should have the same performance in both versions.