InstanceCounting - CocoaDev

I’m working on a framework with 25-30 classes, and right now I’m in a testing phase, writing nice test cases for most of the classes. While doing this I discover lots of memory leaks, and fix them. However, I only discover the leaks as a result of testing the other code, so I’m probably missing some. In one of the cases, I wrote a simple addition to one of my classes, so that it incremented a counter whenever it was alloc’ed and decremented the same counter when it was dealloc’ed, effectively giving me a counter telling me how many instances of this class that were around at any given time. Then I calculated the difference between the number of instances before the tested code, and compared that to the number after (making sure that I had allocated a new autorelease pool for that code, and released it before the comparation). This was very handy for detecting where the memory leaks actually occured.

Now, I want to do this with any class. I know that there are two utilities called OmniObjectMeter and ObjectAlloc, that can do something like this. But what I want to do is to include this check in my testcases, which means that running ObjectAlloc or whatever is not an option. What I want to do is call a function that gives me the current instance count of a named class (any class, not just my own), then execute some code and compare the new result from that function with the old in an assertion or something. Then I can select the test target in my project, type command-r and just wait for the message “All tests passed”.

So, how do I do this? Apple and Omni knows how, so it must be possible.

–TheoHultberg/Iconara

You could try using MethodSwizzling to add to NSObject’s allocWithZone:/retain/release methods. – KritTer

Nice idea, I will try this out and report back. – TheoHultberg/Iconara

OK, here’s my implementation: (link removed, see below instead)

Example

// wrap the counting in an autorelease pool, so that we can // release any autoreleased objects before counting NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

int count;

IXStartInstanceCounting();

count = IXInstaceCountForClass( [Foo class] );

doSomethingThatMightLeakMemory();

// important! if the pool is not released, the instance count // will be higher because of any autoreleased objects in the pool [pool release];

// check so that the number of instances of Foo is the same as // before the function call that might leak (in this case zero) NSCAssert( diff == IXInstaceCountForClass( [Foo class] ), @”Leaking memory” );

IXEndInstanceCounting();

You can also use the function IXAllInstanceCounts() to get a dictionary with all the classes that have been allocated since the count started, and the number of instances of them.

I have decided on having a start and end function since the code that does the counting shouldn’t be on always (it’s a lot of uneccesary instructions if you’re not interested in the counting).

– TheoHultberg/Iconara

Can you rewrite your code to automatically report *all memory leaks? Having to do it per class could well miss mistakes, e.g. where you used a temporary NSString and forgot to release it properly. – KritTer*

Yeah, sure, I’ll do that. There are problems with it though, NSString isn’t just NSString, it’s reported as NSCFString and other kinds as well (because of NSString being a ClassCluster), but what the hell, it’s no big deal. –TheoHultberg/Iconara

OK, now, if you call the function IXEndInstanceCountingAndCheckLeaks() (hey, that was a long name) it’ll trow an exception (IXMemoryLeakException) warning you that there are alloc’ed objects that have not been dealloc’ed. The message will tell you which classes and how many instances there are left. The userInfo dictionary contains all classes and their counts. – TheoHultberg/Iconara (who loves when he can solve his own problems with just a nudge in the right direction from someone, cheers KritTer)

No problemo. In the interest of global harmony…or…something…anyway, I’m posting the code you made up here. We can then scour it and refactor it, and it’s up even if your server perishes :) Take it down of course if you object. – KritTer

Good idea –TheoHultberg

IXInstanceCounting.h

@header IXInstanceCounting
@abstract This is a collection of functions to enable instance counting
@discussion Instance counting is a way to count how many instances of a
class that exist in the scope of a program at a given time.
It can be used to discover and track memory leaks, or just to
discover how memory management in a piece of code works. *
Instance counting is not reference counting, the difference is
that the instance count tells you how many instances of a class
(that is, how many objects) exist, whereas reference counting
tells you how many references to a single instance (object)
there are. *
Basic usage:
Cocoa does not support instance counting by itself, so we have
to strap it on somehow. This is done by calling the function
IXStartInstanceCounting before the code you wish to check.
Call the funtion IXEndInstanceCounting to end the instance
counting. In between the two calls you can check the current
number of instances of a class by calling the function
IXInstanceCountForClass with the class that you’re interested
in as an argument. *
The instance count will be relative to when counting started.
If you create twenty instances of NSString, and then start
instance counting, IXInstanceCountForClass will still report
that the instance count of NSString was zero. *
It’s a good idea to create an autorelease pool around the code
you’re checking, since any autoreleased objects otherwise would
report as leaking when the instance counting ended. *
Example:
NSAutoreleasePool *pool;
DOMDocument *document;
int documents, elements, attributes, texts, pis;
IXStartInstanceCounting();
pool = [[NSAutoreleasePool alloc] init];
document = [[DOMBuilder defaultBuilder] buildFromFile:@”XML/build.xml”]; *
documents = IXInstanceCountForClass( [DOMDocument class] );
elements = IXInstanceCountForClass( [DOMElement class] );
attributes = IXInstanceCountForClass( [DOMAttribute class] );
texts = IXInstanceCountForClass( [DOMText class] );
pis = IXInstanceCountForClass( [DOMProcessingInstruction class] ); *
NSLog(
@”There are %d documents, %d elements, %d attributes, %d texts and %d processing instructions”,
documents, elements, attributes, texts, pis
);
[pool release];
IXEndInstanceCounting(); *
Advanced usage:
The function IXEndInstanceCountingAndCheckLeaks can be used to end
the instance counting and throw an exception if any class has
an instance count of more than one. I use this feature in my unit
testing to test complex features that I suspect contain memory leaks.
I end the instance counting with IXEndInstanceCountingAndCheckLeaks,
which throws an exception if any class has a positive instance count.
I catch this exception and trigger an assertion failure, which is
picked up by my unit testing framework, and reported as a test failure. *
Example:
NSAutoreleasePool *pool;
IXStartInstanceCounting();
pool = [[NSAutoreleasePool alloc] init];
// test code goes here *
[pool release];
NS_DURING
IXEndInstanceCountingAndCheckLeaks();
NS_HANDLER
NSAssert ( NO, @”Memory leak!” );
NS_ENDHANDLER *
Notes:
IXStartInstanceCounting will raise an exception if called again without
first having called IXEndInstanceCounting or IXEndInstanceCountingAndCheckLeaks.
IXInstanceCountForClass and IXAllInstanceCounts will raise an
exception if no counting is in progress. *
The instance counts of some classes can sometimes be negative,
this is only natural, since instances created before the start
of the instance counting can be deallocated within the scope of
the instance counting. *
The dictionary returned by IXAllInstanceCounts has class objects
as keys, and instances of the class IXCount as values. Call
the method -value on the IXCount instance to get the instance count.
The reason why the values are not NSNumbers is that NSNumbers are
immutable, and the counts are updated very frequently, you don’t
want to create an throw away massive amounts of objects like that,
especially when doing memory leak checking… *
There is more documentation on the functions below.
*/

#import <Foundation/Foundation.h>

/*!

@extern IXMemoryLeakException
@abstract Raised when a memory leak is discovered,
see IXEndInstanceCountingAndCheckLeaks */ extern NSString *IXMemoryLeakException;

/*!

@extern IXInvalidStateException
@abstract Raised if the instance counting is forced in to an
ivalid state, i.e when start is called twice without
an end in between. */ extern NSString *IXInvalidStateException;

/*!

@function IXStartInstanceCounting
@abstract Call to start instance counting
@discussion Did I mention that you have to call this method
before you want instance counting to begin? *
It is recommended that you create a local autorelease
pool just after calling this function, and release
that pool just before ending the counting. By doing this
you ensure that any autoreleased objects are released
properly and don’t look like unreleased objects in the counts. *
If this method is called again, before the counting has ended
an exception of type IXInvalidStateException will be raised. */ void IXStartInstanceCounting( void );

/*!

@function IXEndInstanceCounting
@abstract Call when instance counting is no longer needed,
@discussion After this function has been called, all counts are lost,
but since the counting is not free, neither in space
nor time, it can be a good idea to end the counting. *
This function has no effect if instance counting has not
started (i.e IXStartInstanceCounting has not been called). */ void IXEndInstanceCounting( void );

/*!

@function IXEndInstanceCountingAndCheckLeaks
@abstract Does what IXEndInstanceCounting does and raises
an exception of type IXMemoryLeakException
if there was any class that had a positive
instance count.
@discussion The message of the exception will contain the names
of the classes that were leaked. The user info
dictionary contains all classes and their instance counts. */ void IXEndInstanceCountingAndCheckLeaks( void );

/*!

@function IXInstanceCountForClass
@abstract Get the number of unique instances there has
been created since instance counting started.
@discussion If the number is negative, it means that
some objects have been alloc’ed before the instance
counting started. *
If instance counting has not been started this function
raised an exception of type IXInvalidStateException
is raised. * */ int IXInstanceCountForClass( Class class );

/*!

@function IXAllInstanceCounts
@abstract Returns a dictionary containing all the counts for all classes
@discussion The keys of the dictionary are the classes, the value
is an object of type IXCount. *
If instance counting has not been started this function
raised an exception of type IXInvalidStateException
is raised. */ NSDictionary *IXAllInstanceCounts( void );

/*!

@class IXCount
@abstract A simple counter class.
@discussion Dictionaries take only objects as values, and the instance
counting scheme needs a counter, so instead of creating
and destroying lots of NSNumbers just to increment
and decrement the instance count of a class, IXCount is used.
You can increment, decrement and get the value. Everything you need. */ @interface IXCount : NSObject { int i; }

/*!

@method increment:
@abstract Increments the value by one, equivalent to ++. */
(void)increment;

/*!

@method decrement:
@abstract Decrements the value by one, equivalent to –. */
(void)decrement;

/*!

@method value:
@abstract Returns the current value as an int. */
(int)value;

@end

IXInstanceCounting.m

#import “/usr/include/objc/objc-class.h”

#import “IXInstanceCounting.h”

void _IXICSwizzle(void); void _IXMethodSwizzle(Class aClass, SEL orig_sel, SEL alt_sel);

NSString *IXMemoryLeakException = @”IXMemoryLeakException”; NSString *IXInvalidStateException = @”IXInvalidStateException”;

static NSMutableDictionary *IXInstanceCounts = nil;

@interface NSObject ( InstanceCounting )

(id)ixic_init;
(void)ixic_dealloc;

@end

void IXStartInstanceCounting( ) { if ( IXInstanceCounts == nil ) { [IXInstanceCounts release]; IXInstanceCounts = [[NSMutableDictionary alloc] init];

	_IXICSwizzle();
} else {
	[NSException raise:IXInvalidStateException
	            format:@"Instance counting already in progress"];
} }

void IXEndInstanceCounting( ) { if ( IXInstanceCounts != nil ) { _IXICSwizzle();

	[IXInstanceCounts release];

	IXInstanceCounts = nil;
} }

int IXInstanceCountForClass( Class class ) { if ( IXInstanceCounts != nil ) { IXCount *i = [IXInstanceCounts objectForKey:class];

	return [i value];
} else {
	[NSException raise:IXInvalidStateException
	            format:@"Instance counting not in progress"];
	return nil;
} }

NSDictionary *IXAllInstanceCounts( ) { if ( IXInstanceCounts != nil ) { return IXInstanceCounts; } else { [NSException raise:IXInvalidStateException format:@”Instance counting not in progress”]; return nil; } }

void IXEndInstanceCountingAndCheckLeaks( ) { if ( IXInstanceCounts != nil ) { NSException *exception; NSMutableDictionary *leaks = [NSMutableDictionary dictionary]; NSMutableString *leakedClasses = [NSMutableString string]; NSEnumerator *e; Class c;

	_IXICSwizzle();

	e = [IXInstanceCounts keyEnumerator];
	
	if ( c = [e nextObject] ) {
		IXCount *count = [IXInstanceCounts objectForKey:c];
		
		if ( [count value] > 0 ) {
			[leakedClasses appendFormat:@"%@ (%d)", NSStringFromClass(c), [count value]];
		}
	}
	
	while ( c = [e nextObject] ) {
		IXCount *count = [IXInstanceCounts objectForKey:c];
	
		if ( [count value] > 0 ) {
			[leakedClasses appendFormat:@", %@ (%d)", NSStringFromClass(c), [count value]];
			[leaks setObject:count forKey:c];
		}
	}
	
	if ( [leaks count] > 0 ) {
		NSString *reason = [NSString stringWithFormat:@"Memory leak detected: %@", leakedClasses];
	
		exception = [NSException exceptionWithName:IXMemoryLeakException 
		                                    reason:reason
		                                  userInfo:IXInstanceCounts];
	} else {
		exception = nil;
	}

	[IXInstanceCounts release];

	IXInstanceCounts = nil;
	
	[exception raise];
} else {
	[NSException raise:IXInvalidStateException
	            format:@"Instance counting not in progress"];
}  }

void _IXICSwizzle( ) { _IXMethodSwizzle([NSObject class], @selector(init), @selector(ixic_init)); _IXMethodSwizzle([NSObject class], @selector(dealloc), @selector(ixic_dealloc)); }

void _IXMethodSwizzle(Class aClass, SEL orig_sel, SEL alt_sel) { /* * IXMethodSwizzle * This function exchanges one implementation of * a method with another, it is used by IXStartInstanceCounting * and IXEndInstanceCounting to enable or disable the instance * counting scheme. * Kudos to Jack Nutting & Kritter for this code. See * http://www.cocoadev.com/index.pl?MethodSwizzling * for more information. */

Method orig_method = nil, alt_method = nil;

// First, look for the methods
orig_method = class_getInstanceMethod(aClass, orig_sel);
alt_method = class_getInstanceMethod(aClass, alt_sel);

// If both are found, swizzle them
if ((orig_method != nil) && (alt_method != nil)) {
	char *temp1;
	IMP temp2;

	temp1 = orig_method->method_types;
	orig_method->method_types = alt_method->method_types;
	alt_method->method_types = temp1;

	temp2 = orig_method->method_imp;
	orig_method->method_imp = alt_method->method_imp;
	alt_method->method_imp = temp2;
} }

@implementation IXCount

(id)init { self = [super init]; i = 0; return self; }
(void)increment { i++; }
(void)decrement { i–; }
(int)value { return i; }
(NSString *)description { return [NSString stringWithFormat:@”IXCount[value=%d]”, i]; }

@end

@implementation NSObject ( InstanceCounting )

(id)ixic_init { if ( [self class] != [IXCount class] ) { IXCount *i = [IXInstanceCounts objectForKey:[self class]];
```
  if ( i == nil ) {
      i = [[IXCount alloc] init];
      [IXInstanceCounts setObject:i forKey:[self class]];
  }
	
  [i increment];   }
```
return [self ixic_init]; }
(void)ixic_dealloc { if ( [self class] != [IXCount class] ) { IXCount *i = [IXInstanceCounts objectForKey:[self class]];
```
  if ( i == nil ) {
      i = [[IXCount alloc] init];
      [IXInstanceCounts setObject:i forKey:[self class]];
  }

  [i decrement];   }
```
[self ixic_dealloc]; }

@end

Changes:

Moved an import to the .m –Theo
Fixed a bug in IXEndInstanceCountingAndCheckLeaks, the exception would be raised before the instance counts dictionary was emptied. –Theo
Added state checks, will raise an exception if instance counting is already in progress (currently only supports one counting at a time, could perhaps be extended to allow for several counts at the same time). –Theo
Added loads of documentation to the header. –Theo