Question

Situation:

I need to pass an Objective-C object to an asynchronous C API as an opaque reference (void*) which will later be passed to the callback function I provide. The callback then calls a method on the object. The code needs to work in the presence of garbage collection, and the object must not be GC’d between my call to the C API and the time my callback is called by it.

The NSGarbageCollector class provides the disableCollectorForPointer: and enableCollectorForPointer: methods for marking and unmarking objects as uncollectable roots.

Question:

What I can’t work out from the docs and searching the web is if the calls to disableCollectorForPointer: are counted and must be balanced by the same number of enableCollectorForPointer: calls. If this is not the case and each object is either flagged as root or not, calling enableCollectorForPointer: in my callback might clear an existing root flag set by some other code, causing the object to be collected even though it shouldn’t!

The alternative I’ve seen is to use CFRetain and CFRelease – are these safe to use on my own NSObject subclasses? I’ve only used these functions on toll-free-bridged CF objects before.

Bonus points for answers which provide evidence. I see disableCollectorForPointer: recommended all over the place, with no mention of this safety aspect.

Notes:

• I have to support garbage collection as this code will be used by a PrefPane for System Preferences. The 64-bit version of a PrefPane must use garbage collection. So using ARC or manual refcounting is not an option.
• The C API is one of Apple’s (IOKit) so I have no control over it either.

Answer 1

I think I’ve found the answer. Source code for the garbage collector doesn’t seem to be available, but the header file declaring the interface for NSGarbageCollector, NSGarbageCollector.h from the Foundation.framework contains the following:

// references outside the heap, globals, and the stack, e.g. unscanned memory, malloc memory, must be tracked by the collector
- (void)disableCollectorForPointer:(void *)ptr;     // this pointer will not be collected...
- (void)enableCollectorForPointer:(void *)ptr;      // ...until this (stacking) call is made

Note the “stacking” comment – I assume this means that calls are indeed counted? More evidence still welcome!

Update:

Just to be really sure, I decided to test my hypothesis using a little test program (gcbridgetest.m):

#import <Foundation/Foundation.h>

@interface PJGarbageCollectionTest : NSObject
@end

@implementation PJGarbageCollectionTest

- (id)init
{
    self = [super init];
    if (!self) return nil;
    NSLog(@"%@ -init", self);
    return self;
}

- (void)finalize
{
    NSLog(@"%@ -finalize", self);
    [super finalize];
}

@end

static void* ext_ptr1 = NULL;
static void* ext_ptr2 = NULL;

static void create()
{
    PJGarbageCollectionTest* test = [[PJGarbageCollectionTest alloc] init];
    [[NSGarbageCollector defaultCollector] disableCollectorForPointer:test];
    ext_ptr1 = test;
    [[NSGarbageCollector defaultCollector] disableCollectorForPointer:test];
    ext_ptr2 = test;
}

static void killref(void** ext_ptr)
{
    [[NSGarbageCollector defaultCollector] enableCollectorForPointer:*ext_ptr];
    *ext_ptr = NULL;
}


int main()
{
    NSLog(@"collector: %@", [NSGarbageCollector defaultCollector]);
    create();
    NSLog(@"Collecting with 2 external references");
    [[NSGarbageCollector defaultCollector] collectExhaustively];
    killref(&ext_ptr1);
    NSLog(@"Collecting with 1 external reference");
    [[NSGarbageCollector defaultCollector] collectExhaustively];
    killref(&ext_ptr2);
    NSLog(@"Collecting with 0 external references");
    [[NSGarbageCollector defaultCollector] collectExhaustively];
    return 0;
}

Compiled with gcc -fobjc-gc-only -g -Wall -Wextra -ObjC gcbridgetest.m -framework Foundation -o gcbridgetest and run as ./gcbridgetest, it gives the following output, confirming that enable/disableCollectorForPointer: calls are indeed counted:

2012-06-12 16:08:08.278 gcbridgetest[29712:903] collector: <NSGarbageCollector: 0x20000f420>
2012-06-12 16:08:08.281 gcbridgetest[29712:903] <PJGarbageCollectionTest: 0x20000ee60> -init
2012-06-12 16:08:08.284 gcbridgetest[29712:903] Collecting with 2 external references
2012-06-12 16:08:08.285 gcbridgetest[29712:903] Collecting with 1 external reference
2012-06-12 16:08:08.286 gcbridgetest[29712:903] Collecting with 0 external references
2012-06-12 16:08:08.286 gcbridgetest[29712:903] <PJGarbageCollectionTest: 0x20000ee60> -finalize