iOS 中的 MMap 内存映射技术详解

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

// 打开文件
int fd = open("/path/to/file", O_RDWR);
if (fd == -1) {
    perror("open");
    return;
}

// 获取文件大小
struct stat sb;
if (fstat(fd, &sb) == -1) {
    perror("fstat");
    close(fd);
    return;
}

// 内存映射
void *addr = mmap(NULL,                    // 让系统选择映射地址
                  sb.st_size,              // 映射大小
                  PROT_READ | PROT_WRITE,  // 读写权限
                  MAP_SHARED,              // 共享映射
                  fd,                      // 文件描述符
                  0);                      // 文件偏移量

if (addr == MAP_FAILED) {
    perror("mmap");
    close(fd);
    return;
}

// 使用映射区域
char *data = (char *)addr;
data[0] = 'H';
data[1] = 'e';
data[2] = 'l';
data[3] = 'l';
data[4] = 'o';

// 同步到磁盘（可选）
msync(addr, sb.st_size, MS_SYNC);

// 解除映射
munmap(addr, sb.st_size);

// 关闭文件
close(fd);

#import <Foundation/Foundation.h>
#import <sys/mman.h>
#import <sys/stat.h>
#import <fcntl.h>

@interface MMapHelper : NSObject

+ (NSData *)mapFileAtPath:(NSString *)path error:(NSError **)error;

@end

@implementation MMapHelper

+ (NSData *)mapFileAtPath:(NSString *)path error:(NSError **)error {
    const char *filePath = [path UTF8String];
    
    // 打开文件
    int fd = open(filePath, O_RDONLY);
    if (fd == -1) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        return nil;
    }
    
    // 获取文件大小
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        close(fd);
        return nil;
    }
    
    // 内存映射
    void *addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    close(fd); // 映射后可以关闭文件描述符
    
    if (addr == MAP_FAILED) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        return nil;
    }
    
    // 包装为 NSData
    return [NSData dataWithBytesNoCopy:addr
                                length:sb.st_size
                          freeWhenDone:YES];
}

@end

// 使用示例
NSError *error;
NSData *data = [MMapHelper mapFileAtPath:@"/path/to/file" error:&error];
if (data) {
    // 直接访问数据
    const char *bytes = data.bytes;
    NSLog(@"First byte: %c", bytes[0]);
}

import Foundation

class MMapHelper {
    
    /// 使用 mmap 映射文件
    static func mapFile(at url: URL) throws -> Data {
        let fd = open(url.path, O_RDONLY)
        guard fd >= 0 else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        defer { close(fd) }
        
        // 获取文件大小
        var sb = stat()
        guard fstat(fd, &sb) == 0 else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        
        let size = Int(sb.st_size)
        
        // 内存映射
        let addr = mmap(nil, size, PROT_READ, MAP_PRIVATE, fd, 0)
        guard addr != MAP_FAILED else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        
        // 包装为 Data（自动管理内存）
        return Data(bytesNoCopy: addr!, count: size, deallocator: .custom { ptr, length in
            munmap(ptr, length)
        })
    }
    
    /// 使用系统 API（推荐）
    static func mapFileUsingFoundation(at url: URL) throws -> Data {
        return try Data(contentsOf: url, options: .alwaysMapped)
    }
}

// 使用示例
do {
    let fileURL = URL(fileURLWithPath: "/path/to/file")
    let data = try MMapHelper.mapFile(at: fileURL)
    
    // 访问数据
    data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in
        if let baseAddress = ptr.baseAddress {
            let firstByte = baseAddress.load(as: UInt8.self)
            print("First byte: \(firstByte)")
        }
    }
} catch {
    print("Error: \(error)")
}

import Foundation

class SharedMemory {
    private let name: String
    private var fileDescriptor: Int32 = -1
    private var mappedAddress: UnsafeMutableRawPointer?
    private let size: Int
    
    init(name: String, size: Int) {
        self.name = name
        self.size = size
    }
    
    /// 创建共享内存
    func create() throws {
        // 创建共享内存对象
        fileDescriptor = shm_open(name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)
        guard fileDescriptor >= 0 else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        
        // 设置共享内存大小
        guard ftruncate(fileDescriptor, off_t(size)) == 0 else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        
        // 映射到进程地址空间
        mappedAddress = mmap(nil, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor, 0)
        guard mappedAddress != MAP_FAILED else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
    }
    
    /// 打开已存在的共享内存
    func open() throws {
        fileDescriptor = shm_open(name, O_RDWR, 0)
        guard fileDescriptor >= 0 else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
        
        mappedAddress = mmap(nil, size, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor, 0)
        guard mappedAddress != MAP_FAILED else {
            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno))
        }
    }
    
    /// 写入数据
    func write(data: Data) {
        guard let address = mappedAddress else { return }
        data.withUnsafeBytes { ptr in
            memcpy(address, ptr.baseAddress, min(data.count, size))
        }
    }
    
    /// 读取数据
    func read(length: Int) -> Data? {
        guard let address = mappedAddress else { return nil }
        return Data(bytes: address, count: min(length, size))
    }
    
    /// 清理资源
    func close() {
        if let address = mappedAddress {
            munmap(address, size)
            mappedAddress = nil
        }
        
        if fileDescriptor >= 0 {
            Darwin.close(fileDescriptor)
            fileDescriptor = -1
        }
    }
    
    /// 删除共享内存
    func unlink() {
        shm_unlink(name)
    }
    
    deinit {
        close()
    }
}

// 进程 A：创建并写入
let sharedMem = SharedMemory(name: "/my_shared_memory", size: 1024)
try? sharedMem.create()
let message = "Hello from Process A".data(using: .utf8)!
sharedMem.write(data: message)

// 进程 B：读取
let sharedMem2 = SharedMemory(name: "/my_shared_memory", size: 1024)
try? sharedMem2.open()
if let data = sharedMem2.read(length: 1024),
   let message = String(data: data, encoding: .utf8) {
    print("Received: \(message)")
}

#import <Foundation/Foundation.h>
#import <sys/mman.h>
#import <fcntl.h>

@interface SharedMemory : NSObject

@property (nonatomic, readonly) NSString *name;
@property (nonatomic, readonly) size_t size;

- (instancetype)initWithName:(NSString *)name size:(size_t)size;
- (BOOL)create:(NSError **)error;
- (BOOL)open:(NSError **)error;
- (void)writeData:(NSData *)data;
- (NSData *)readDataWithLength:(size_t)length;
- (void)close;
- (void)unlink;

@end

@implementation SharedMemory {
    int _fd;
    void *_addr;
}

- (instancetype)initWithName:(NSString *)name size:(size_t)size {
    if (self = [super init]) {
        _name = name;
        _size = size;
        _fd = -1;
        _addr = NULL;
    }
    return self;
}

- (BOOL)create:(NSError **)error {
    _fd = shm_open([_name UTF8String], O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    if (_fd < 0) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        return NO;
    }
    
    if (ftruncate(_fd, _size) != 0) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        close(_fd);
        return NO;
    }
    
    _addr = mmap(NULL, _size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
    if (_addr == MAP_FAILED) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        close(_fd);
        return NO;
    }
    
    return YES;
}

- (BOOL)open:(NSError **)error {
    _fd = shm_open([_name UTF8String], O_RDWR, 0);
    if (_fd < 0) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        return NO;
    }
    
    _addr = mmap(NULL, _size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
    if (_addr == MAP_FAILED) {
        if (error) {
            *error = [NSError errorWithDomain:NSPOSIXErrorDomain
                                        code:errno
                                    userInfo:nil];
        }
        close(_fd);
        return NO;
    }
    
    return YES;
}

- (void)writeData:(NSData *)data {
    if (_addr) {
        memcpy(_addr, data.bytes, MIN(data.length, _size));
    }
}

- (NSData *)readDataWithLength:(size_t)length {
    if (_addr) {
        return [NSData dataWithBytes:_addr length:MIN(length, _size)];
    }
    return nil;
}

- (void)close {
    if (_addr) {
        munmap(_addr, _size);
        _addr = NULL;
    }
    if (_fd >= 0) {
        close(_fd);
        _fd = -1;
    }
}

- (void)unlink {
    shm_unlink([_name UTF8String]);
}

- (void)dealloc {
    [self close];
}

@end