Proper disposal of a Grand Central Dispatch I/O channel - objective-c

Question

I'm confused about how to correctly dispose of a Grand Central Dispatch I/O channel once I'm finished with it. The following (simplified) example causes a crash on some private dispatch queue with the message: BUG IN CLIENT OF LIBDISPATCH: Over-resume of an object:
- (void)beginReading {
dispatch_io_t channel;
channel = dispatch_io_create_with_path(DISPATCH_IO_RANDOM,
"/Path/To/Some/File",
O_RDONLY,
0 /*mode*/,
someQueue,
^(int errorCode) {
// Cleanup handler; executed once channel is closed.
// (Or fails to open.)
});
// Schedule the read operation
dispatch_io_read(channel, 0, SIZE_MAX, someQueue, ^(bool done, dispatch_data_t data, int errorCode) {
NSError *error = (errorCode!=0) ? [NSError errorWithDomain:NSPOSIXErrorDomain code:errorCode userInfo:nil] : nil;
[self didReadChunk:data isEOF:done error:error];
});
// No more read operations to come, so we can safely close the channel.
// (Or can we?)
dispatch_io_close(channel, 0);
// We don't need a reference to the channel anymore
dispatch_release(channel);
}
I'm guessing that dispatch_io_close() schedules some asynchronous operation to close the channel, and until this operation has finished executing, you mustn't call dispatch_release()on the channel or bad things will happen. But this would be quite surprising: other GCD asynchronous functions, such as dispatch_async(), don't have this restriction. Further, the dispatch_io_close() call doesn't seem to be strictly necessary, as libdispatch appears to close the file with the last call to dispatch_release() on the channel.
It seems to follow from this that if you call dispatch_io_close, you must take care that not to release the channel until its cleanup handler has run. This so irritating that I wonder if it's a bug. Or perhaps I'm missing something?

Answer 1

It turns out this is a bug (radar #10246694). Further experimenting seems to indicate that it only affects path-based dispatch channels, i.e. those created with dispatch_io_create_with_path(), as opposed to dispatch_io_create().

Answer 2

Declare these variables, globally:
dispatch_fd_t write_dfd, read_dfd;
dispatch_io_t write_channel, read_channel;
To open a channel for writing a Metal texture to a file:
NSString *documentDictionary = [(NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask, YES)) objectAtIndex:0];
    
        write_dfd = open([[NSString stringWithFormat:#"%#/textures.data", documentDictionary] UTF8String], O_CREAT | O_TRUNC | O_WRONLY | O_APPEND);
        write_channel = dispatch_io_create(DISPATCH_IO_STREAM, write_dfd, AppServices.textureQueue, ^(int error) {
            NSLog(#"Write channel to %# open", documentDictionary);
        });
        
        dispatch_io_set_low_water(write_channel, 33177608);
        dispatch_io_set_high_water(write_channel, 33177608);
To write a Metal texture to a file:
void *write_buffer = malloc([_textureBGRA allocatedSize]);
    [_textureBGRA getBytes:write_buffer bytesPerRow:15360 fromRegion:MTLRegionMake2D(0.0, 0.0, [_textureBGRA width], [_textureBGRA height]) mipmapLevel:0];
    dispatch_data_t message_data = dispatch_data_create(write_buffer, [_textureBGRA allocatedSize], AppServices.textureQueue, ^{
        free((void *)write_buffer);
    });
    dispatch_io_write(write_channel, 0, message_data, AppServices.textureQueue, ^(bool done, dispatch_data_t  _Nullable data, int error) {
        if (done)
        {
            NSLog(#"Wrote %lu bytes",  [_textureBGRA allocatedSize]);
        }
    });
To close the file:
dispatch_io_close(write_channel, 0);
close(write_dfd);
To open a channel for reading a Metal texture from a file:
NSString *documentDictionary = [(NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)) objectAtIndex:0];
        
        read_dfd = open([[NSString stringWithFormat:#"%#/textures.data", documentDictionary] UTF8String], O_RDONLY | O_NONBLOCK);
        read_channel = dispatch_io_create(DISPATCH_IO_STREAM, read_dfd, dispatch_get_main_queue(), ^(int error) {
            NSLog(#"Read channel to %# open", documentDictionary);
        });
        
        dispatch_io_set_low_water(read_channel, 33177608);
        dispatch_io_set_high_water(read_channel, 33177608);
To read a Metal texture from a file:
dispatch_io_read(read_channel, [_textureBGRA allocatedSize] * textureIndex, [_textureBGRA allocatedSize], dispatch_get_main_queue(), ^(bool done, dispatch_data_t  _Nullable data, int error) {
                if ( read_channel == nil )
                    return;
                
                if ( error != 0 ) {
                    __autoreleasing NSError * nsError = nil;
                    nsError = [[NSError alloc] initWithDomain:NSPOSIXErrorDomain code:error userInfo:nil];
                    NSLog(#"Error reading from channel: %#", nsError.localizedDescription);
                    return;
                }
                
                // read data
                void *buffer = malloc([_textureBGRA allocatedSize]);
                dispatch_data_t mapped_data = dispatch_data_create_map(data, buffer, NULL);
                dispatch_data_apply(mapped_data, ^bool(dispatch_data_t region, size_t offset, const void *buffer, size_t size) {
                    NSUInteger rowBytes = 3840 * 4;
                    NSUInteger imageBytes = rowBytes * 2160;
                    MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
                                                                                                                 width:3840
                                                                                                                height:2160
                                                                                                             mipmapped:NO];
                    textureDescriptor.usage = MTLTextureUsageShaderRead;
                    id<MTLTexture> texture = [_device newTextureWithDescriptor:textureDescriptor];
                    [texture replaceRegion:MTLRegionMake2D(0, 0, 3840, 2160)
                               mipmapLevel:0 slice:0 withBytes:buffer
                               bytesPerRow:rowBytes bytesPerImage:imageBytes];
                    dispatch_async(dispatch_get_main_queue(), ^{
                        NSString *label = [NSString stringWithFormat:#"%lu", textureIndex];
                        const char *queue_index = [[NSString stringWithFormat:#"%lu", textureIndex] cStringUsingEncoding:NSUTF8StringEncoding];
                        dispatch_queue_set_specific(AppServices.textureQueue, queue_index, (void *)CFBridgingRetain(texture), NULL);
                        [self.mediaCollectionView insertItemForQueueDataIndex:label];
                        textureIndex++;
                    });
                    return TRUE;
                });
            });
To close the file:
dispatch_io_close(read_channel, 0);
close(read_dfd);