前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >iOS OC 对象的内存对齐原则

iOS OC 对象的内存对齐原则

作者头像
网罗开发
发布2021-07-21 17:19:24
5130
发布2021-07-21 17:19:24
举报
文章被收录于专栏:网罗开发网罗开发

问题的引入

初始化一个 OC 类,具有如下属性:

代码语言:javascript
复制
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface LGTeacher : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
@property (nonatomic, assign) long height;
@property (nonatomic, strong) NSString *hobby;

@end

NS_ASSUME_NONNULL_END

初始化对象,并获取对象的内存 size

代码语言:javascript
复制
LGTeacher  *p = [[LGTeacher alloc] init];
p.name = @"LG_Cooci";
p.age  = 18;
p.height = 185;
p.hobby  = @"女";

NSLog(@"%lu - %lu",class_getInstanceSize([p class]),malloc_size((__bridge const void *)(p)));

打印结果:

由以上打印结果可以看出 class_getInstanceSizemalloc_size 获取到的内存大小不一样,那么是什么导致的两者获取同一对象的内存大小不一样呢?我们下一步继续探索。

首先我们先手动计算一下这个对象所占的内存:

  • isa -- 8字节
  • name -- 8字节
  • age -- 4字节
  • height -- 8字节
  • hobby -- 8字节

总计 36 字节。

我们跟踪 objc 源码可以发现改变 size 的地方有两个地方:

  • instanceSize 继续跟踪
    1. instanceSize
代码语言:javascript
复制
size_t instanceSize(size_t extraBytes) const {
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }

        size_t size = alignedInstanceSize() + extraBytes;// alignedInstanceSize
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
}

uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
}

#   define WORD_MASK 7UL
static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}

由以上源码可以得到 instanceSize 使用 8 字节对齐原则处理 Size,并且最小为 16 字节。

    1. calloc

由于 calloc 属于 malloc 源码里面

跟踪 libmalloc 源码:

calloc 源码实现:

代码语言:javascript
复制
void *
calloc(size_t num_items, size_t size)
{
    void *retval;
    retval = malloc_zone_calloc(default_zone, num_items, size);
    if (retval == NULL) {
        errno = ENOMEM;
    }
    return retval;
}

// malloc_zone_calloc
void *
    malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);

    void *ptr;
    if (malloc_check_start && (malloc_check_counter++ >= malloc_check_start)) {
        internal_check();
    }

    ptr = zone->calloc(zone, num_items, size);
    
    if (malloc_logger) {
        malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE | MALLOC_LOG_TYPE_CLEARED, (uintptr_t)zone,
                (uintptr_t)(num_items * size), 0, (uintptr_t)ptr, 0);
    }

    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_END, (uintptr_t)zone, num_items, size, (uintptr_t)ptr);
    return ptr;
}

断点打印 zone->calloc

  • ①:得到其真实调用为 default_zone_calloc
  • ②:搜索 default_zone_calloc 继续跟进,打印 default_zone_calloc 内部的 zone->calloc 得到 nano_calloc
  • ③:分析 nano_calloc 源码可以知道在 _nano_malloc_check_clear 内进行了相关操作
代码语言:javascript
复制
static void *
default_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
    zone = runtime_default_zone();
    
    return zone->calloc(zone, num_items, size);
}

static void *
nano_calloc(nanozone_t *nanozone, size_t num_items, size_t size)
{
    size_t total_bytes;

    if (calloc_get_size(num_items, size, 0, &total_bytes)) {
        return NULL;
    }

    if (total_bytes <= NANO_MAX_SIZE) {
        void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1);
        if (p) {
            return p;
        } else {
            /* FALLTHROUGH to helper zone */
        }
    }
    malloc_zone_t *zone = (malloc_zone_t *)(nanozone->helper_zone);
    return zone->calloc(zone, 1, total_bytes);
}

跳转到 _nano_malloc_check_clear 内部发现代码很多,一脸懵逼,但是仔细一看很多都是做一些容错判断,除去这些代码后,返现与size 有关的只有一行代码:

size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key);

跳转进 segregated_size_to_fit 可以看到又是内存对齐的代码,这里的内存对齐是以16字节原则进行对齐的。

代码语言:javascript
复制
#define SHIFT_NANO_QUANTUM      4
#define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM)   // 16

static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
    size_t k, slot_bytes;

    if (0 == size) {
        size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
    }
    k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
    slot_bytes = k << SHIFT_NANO_QUANTUM;                           // multiply by power of two quanta size
    *pKey = k - 1;                                                  // Zero-based!

    return slot_bytes;
}

总结

经过上述的各种分析,我们可以得到的结论是 instanceSize 是以 8 字节进行对齐的, 后面 calloc 是以 16 字节进行对齐的,说明 calloc 进一步对对象进行了处理。也就解释了我们打印出来的 40-48 了。

由以上可以知道对象申请的内存大小和系统开辟的大小存在不一致的情况,8 字节对齐应用于对象的属性,16 字节对齐应用于对象,由于对象的内存是连续的,这样可以规避一些不必要的风险,以空间换时间来得到更高的安全性。

-End-

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2021-07-07,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 网罗开发 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 问题的引入
  • 总结
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档