iOS中malloc和calloc源码分析

最新推荐文章于 2024-05-03 12:06:54 发布
最新推荐文章于 2024-05-03 12:06:54 发布
阅读量567 收藏
点赞数
分类专栏： OC底层原理 文章标签： ios objective-c 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42376419/article/details/128226480
版权

iOS中malloc和calloc源码分析

calloc

  • 我们知道在iOS创建对象的alloc方法中，最终通过调用calloc方法来开辟内存。如果这里具体流程不够清楚的话，可以参考Runtime源码分析-alloc
  • 那么calloc具体是如何实现的呢？由于在objc4中没有提供该方法，我们通过libmalloc-317.40.8代码去研究。

1. calloc

  • 首先进入calloc方法
void *
calloc(size_t num_items, size_t size)
{
	return _malloc_zone_calloc(default_zone, num_items, size, MZ_POSIX);
}
  • 内部调用了_malloc_zone_calloc()方法

2. _malloc_zone_calloc

MALLOC_NOINLINE
static void *
_malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size,
		malloc_zone_options_t mzo)
{
	MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);

	void *ptr;
	if (malloc_check_start) {
		internal_check();
	}
    // ptr指针指向一块内存
	ptr = zone->calloc(zone, num_items, size);

	if (os_unlikely(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);
	if (os_unlikely(ptr == NULL)) {
		malloc_set_errno_fast(mzo, ENOMEM);
	}
	return ptr;
}

  • 该方法中最终返回结果是一个指针，所以最重要的是13行。它创建了一块内存，并让ptr指向它。

  • 这个时候，我们点击zone->calloc跳转对应的实现，发现点不进去。这个时候才用汇编方式，看到该方法最终跳转至default_zone_calloc方法

3. default_zone_calloc

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);
}
  • 该方法内部调用 zone->calloc方法，仍然点不进去。再次使用汇编方法，发现该方法跳转至nano_calloc

4. nano_calloc

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);
}
  • 此处我们还是先看返回值，发现有三处返回。第一处直接返回NULL，这肯定不是我们需要的答案，直接忽略。剩下两处，无法确定。这个时候通过断点调试，发现一般情况走的是_nano_malloc_check_clear方法

5. _nano_malloc_check_clear

static void *
_nano_malloc_check_clear(nanozone_t *nanozone, size_t size, boolean_t cleared_requested)
{
	MALLOC_TRACE(TRACE_nano_malloc, (uintptr_t)nanozone, size, cleared_requested, 0);

	void *ptr;
	size_t slot_key;
    // 1. 计算合适的内存大小
	size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key); // Note slot_key is set here
	mag_index_t mag_index = nano_mag_index(nanozone);

	nano_meta_admin_t pMeta = &(nanozone->meta_data[mag_index][slot_key]);

    // 2. 开辟一片内存，并让ptr指针指向这块内存
	ptr = OSAtomicDequeue(&(pMeta->slot_LIFO), offsetof(struct chained_block_s, next));
	if (ptr) {
		unsigned debug_flags = nanozone->debug_flags;
#if NANO_FREE_DEQUEUE_DILIGENCE
		size_t gotSize;
		nano_blk_addr_t p; // the compiler holds this in a register

		p.addr = (uint64_t)ptr; // Begin the dissection of ptr
		if (NANOZONE_SIGNATURE != p.fields.nano_signature) {
			malloc_zone_error(debug_flags, true,
					"Invalid signature for pointer %p dequeued from free list\n",
					ptr);
		}

		if (mag_index != p.fields.nano_mag_index) {
			malloc_zone_error(debug_flags, true,
					"Mismatched magazine for pointer %p dequeued from free list\n",
					ptr);
		}

		gotSize = _nano_vet_and_size_of_free(nanozone, ptr);
		if (0 == gotSize) {
			malloc_zone_error(debug_flags, true,
					"Invalid pointer %p dequeued from free list\n", ptr);
		}
		if (gotSize != slot_bytes) {
			malloc_zone_error(debug_flags, true,
					"Mismatched size for pointer %p dequeued from free list\n",
					ptr);
		}

		if (!_nano_block_has_canary_value(nanozone, ptr)) {
			malloc_zone_error(debug_flags, true,
					"Heap corruption detected, free list canary is damaged for %p\n"
					"*** Incorrect guard value: %lu\n", ptr,
					((chained_block_t)ptr)->double_free_guard);
		}

#if defined(DEBUG)
		void *next = (void *)(((chained_block_t)ptr)->next);
		if (next) {
			p.addr = (uint64_t)next; // Begin the dissection of next
			if (NANOZONE_SIGNATURE != p.fields.nano_signature) {
				malloc_zone_error(debug_flags, true,
						"Invalid next signature for pointer %p dequeued from free "
						"list, next = %p\n", ptr, "next");
			}

			if (mag_index != p.fields.nano_mag_index) {
				malloc_zone_error(debug_flags, true,
						"Mismatched next magazine for pointer %p dequeued from "
						"free list, next = %p\n", ptr, next);
			}

			gotSize = _nano_vet_and_size_of_free(nanozone, next);
			if (0 == gotSize) {
				malloc_zone_error(debug_flags, true,
						"Invalid next for pointer %p dequeued from free list, "
						"next = %p\n", ptr, next);
			}
			if (gotSize != slot_bytes) {
				malloc_zone_error(debug_flags, true,
						"Mismatched next size for pointer %p dequeued from free "
						"list, next = %p\n", ptr, next);
			}
		}
#endif /* DEBUG */
#endif /* NANO_FREE_DEQUEUE_DILIGENCE */

		((chained_block_t)ptr)->double_free_guard = 0;
		((chained_block_t)ptr)->next = NULL; // clear out next pointer to protect free list
	} else {
        // 如果ptr指针为空，则去去找下一块合适内存
		ptr = segregated_next_block(nanozone, pMeta, slot_bytes, mag_index);
	}
	
    // 3. 是否给内存进行初始化
	if (cleared_requested && ptr) {
		memset(ptr, 0, slot_bytes); // TODO: Needs a memory barrier after memset to ensure zeroes land first?
	}
	return ptr;
}
  • 该方法中，它主要干了三件事：
    1. segregated_size_to_fit：计算需要开辟的内存大小
    2. OSAtomicDequeue或者segregated_next_block：开辟内存
    3. memset(ptr, 0, slot_bytes);：是否进行初始化
segregated_size_to_fit
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
	}
    // 内存按照16字节对齐
    // k = (size + 16 - 1) >> 4 右移4位
	k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
    // slot_bytes = k << 4 左移4位
	slot_bytes = k << SHIFT_NANO_QUANTUM;							// multiply by power of two quanta size
	*pKey = k - 1;													// Zero-based!

	return slot_bytes;
}
  • 这里主要是内存对齐算法，算法流程是：
    1. 当前size + 15，左移4位
    2. 再把上面的值，右移4位
  • 具体计算过程如下：假设size为8字节
    1. (size + NANO_REGIME_QUANTA_SIZE - 1) = 8 + 15 = 23，用二进制表示：0001 0111
    2. k >> SHIFT_NANO_QUANTUM，用二进制表示：0000 0001
    3. k << SHIFT_NANO_QUANTUM，用二进制表示：0001 0000
    4. 最终结果是16字节，实现了按照16字节对齐。
OSAtomicDequeue或者segregated_next_block
  • 首先会通过OSAtomicDequeue方法来开辟内存
    • 如果开辟成功，则返回内存首地址给ptr。然后对ptr进行一系列的验证
    • 如果开辟失败，则通过segregated_next_block方法进行再次尝试开辟
static MALLOC_INLINE void *
segregated_next_block(nanozone_t *nanozone, nano_meta_admin_t pMeta, size_t slot_bytes, unsigned int mag_index)
{
	while (1) {
        // 当前这块pMeta可用内存结束地址
		uintptr_t theLimit = pMeta->slot_limit_addr; // Capture the slot limit that bounds slot_bump_addr right now
		uintptr_t b = OSAtomicAdd64Barrier(slot_bytes, (volatile int64_t *)&(pMeta->slot_bump_addr));
        // 减去添加的偏移量，获取当前可以获取的地址
		b -= slot_bytes; 

		if (b < theLimit) {   // Did we stay within the bound of the present slot allocation?
            // 如果地址还在范围之内，则返回地址
			return (void *)b; 
		} else {
            // pMeta这块内存已经用完了
			if (pMeta->slot_exhausted) {
				pMeta->slot_bump_addr = theLimit;
				return 0;				 // We're toast
			} else {
				// One thread will grow the heap, others will see its been grown and retry allocation
				_malloc_lock_lock(&nanozone->band_resupply_lock[mag_index]);
				// 由于多线程，这里再次进行检查是否用完
				if (pMeta->slot_exhausted) {
					_malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
					return 0; // Toast
				} else if (b < pMeta->slot_limit_addr) {
                    // 如果小于最大限制地址，当重新申请一个新的band后，重新尝试while
					_malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
					continue; 
				} else if (segregated_band_grow(nanozone, pMeta, slot_bytes, mag_index)) {
                    // 申请新的band成功，重新尝试while
					_malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
					continue; 
				} else {
					pMeta->slot_exhausted = TRUE;
					pMeta->slot_bump_addr = theLimit;
					_malloc_lock_unlock(&nanozone->band_resupply_lock[mag_index]);
					return 0;
				}
			}
		}
	}
}
  • 该方法里面主要是去堆上获取一块合适的内存。
memset(ptr, 0, slot_bytes)
  • 根据传入cleared_requested参数，来决定是否给内存初始化为0

malloc

  • 在底层中，除了常用的alloc方法之外，还有malloc也经常使用。我们看一下实现，发现具体有什么区别。

1. malloc

void *
malloc(size_t size)
{
	return _malloc_zone_malloc(default_zone, size, MZ_POSIX);
}
  • 内部调用了_malloc_zone_malloc()方法

2. _malloc_zone_malloc

MALLOC_NOINLINE
static void *
_malloc_zone_malloc(malloc_zone_t *zone, size_t size, malloc_zone_options_t mzo)
{
	MALLOC_TRACE(TRACE_malloc | DBG_FUNC_START, (uintptr_t)zone, size, 0, 0);

	void *ptr = NULL;

	if (malloc_check_start) {
		internal_check();
	}
	if (size > MALLOC_ABSOLUTE_MAX_SIZE) {
		goto out;
	}

	ptr = zone->malloc(zone, size);		// if lite zone is passed in then we still call the lite methods

	if (os_unlikely(malloc_logger)) {
		malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE, (uintptr_t)zone, (uintptr_t)size, 0, (uintptr_t)ptr, 0);
	}

	MALLOC_TRACE(TRACE_malloc | DBG_FUNC_END, (uintptr_t)zone, size, (uintptr_t)ptr, 0);
out:
	if (os_unlikely(ptr == NULL)) {
		malloc_set_errno_fast(mzo, ENOMEM);
	}
	return ptr;
}
  • 该方法中最终返回结果是一个指针，所以最重要的是16行。它创建了一块内存，并让ptr指向它。
  • 这个时候点击它的实现，发现也跳转不进去。这个时候还是使用汇编手段，可以得知它调用default_zone_malloc方法

3. default_zone_malloc

static void *
default_zone_malloc(malloc_zone_t *zone, size_t size)
{
	zone = runtime_default_zone();
	
	return zone->malloc(zone, size);
}
  • 该方法调用zone->malloc方法，仍然点不进去，继续查看汇编。发现调用了nano_malloc方法

4. nano_malloc

static void *
nano_malloc(nanozone_t *nanozone, size_t size)
{
	if (size <= NANO_MAX_SIZE) {
		void *p = _nano_malloc_check_clear(nanozone, size, 0);
		if (p) {
			return p;
		} else {
			/* FALLTHROUGH to helper zone */
		}
	}

	malloc_zone_t *zone = (malloc_zone_t *)(nanozone->helper_zone);
	return zone->malloc(zone, size);
}
  • 这里有两处返回值，通过断点调试得知一般走_nano_malloc_check_clear方法
  • 看到这个方法有没有一丝丝熟悉？原来它开辟内存调用的方法和calloc调用的是同一个方法。此处仔细对比发现，虽然是调用同一个方法，但是参数穿的不同
// calloc中
void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1);
// malloc中
void *p = _nano_malloc_check_clear(nanozone, size, 0);

static void *
_nano_malloc_check_clear(nanozone_t *nanozone, size_t size, boolean_t cleared_requested)
  • 发现cleared_requested这个参数传的不同。calloc是1，malloc是0。那个这个参数有什么作用？
  • 我们进入这个方法，发现以下实现
if (cleared_requested && ptr) {
    memset(ptr, 0, slot_bytes);
}
  • 原来是对开辟的内存进行初始化。calloc会对它初始化，malloc不会对它初始化

总结

  • 我们最终可以得出以下结论
  1. malloc和calloc其实底层都调用的同一套开辟内存方法
  2. 不同在于，calloc在开辟完内存会进行初始化，malloc不会进行初始化，则是原始脏数据。如果需要使用malloc这块内存，还需要我们手动初始化
_祀梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中 malloc，calloc，realloc的区别
01-20
C语言中 malloc、calloc、realloc的区别 (1)C语言跟内存分配方式 <1>从静态存储区域分配.        内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在.例如全局变量、static变量. <2>在栈上创建        在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放.栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限. <3>从堆上分配，亦称动态内存分配.        程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放
音频开发中常见的四个错误
LiveVideoStack
10-14 982
以下内容主要为音频开发人员所编写，但同样也能为其他领域并与此相关的开发者带来帮助。在下文当中我将介绍针对开发人员的诊断工具，并分享常见的四个错误以及如何检测问题是否存在并...
iOS-底层原理 31：启动优化之二进制重排
changcongcong_ios的博客
09-25 600
前提，在之前的两篇文章中，大致介绍了一些基本概念以及启动优化的思路，下面来着重介绍一个pre-main阶段的优化方案，即二进制重排，这个方案最开始是由于抖音的这篇文章抖音研发实践：基于二进制文件重排的解决方案 APP启动速度提升超15%火起来的。 二进制重排原理 在虚拟内存部分，我们知道，当进程访问一个虚拟内存page，而对应的物理内存不存在时，会触发缺页中断（Page Fault），因此阻塞进程。此时就需要先加载数据到物理内存，然后再继续访问。这个对性能是有一定影响的。 基于Page Fault，我
C 库函数 calloc()
源代码杀手的博客
08-29 5889
描述 C 库函数 void *calloc(size_t nitems, size_t size) 分配所需的内存空间，并返回一个指向它的指针。malloc 和 calloc 之间的不同点是，malloc 不会设置内存为零，而 calloc 会设置分配的内存为零。 声明 下面是 calloc() 函数的声明。 void *calloc(size_t nitems, size_t size) 参数 nitems – 要被分配的元素个数。 size – 元素的大小。 返回值 该函数返回一个指针，指向已分配的内存
Objc的底层并发API
呆萌院长
07-11 1394
http://www.cocoachina.com/appstore/case/2013/0531/6312.html 本文作者朱念洋：谨以此文献给与我同样有创业梦想的程序员们.   我相信像我一样的程序员一定大有人在，一个人、一身技术、一腔热血，想要涉足手游领域，却不清楚会投入多少。   所以，我把自己的这次游戏开发过程，完整记下来，给与我同样的程序员以
ios基础入门——malloc方法
牟云飞的博客
01-15 5951
char m; scanf(" %c",&m); // 前面加空格是为了去掉空格、回车等操作 NSLog(@"the character is %c",m);     上面这个程序是各位比较熟悉的两个方法一个输入、一个输出，但是如果我改一下改成 char *m; NSLog(@"\n请输入一个字符"); scanf(" %c",m); NSLog(@"\nt
iOS-底层原理 06：malloc 源码分析 思路
lin1109221208的博客
09-09 746
在iOS-底层原理 02：alloc & init & new 源码分析文章中，alloc有3个核心操作，其中一个就是calloc，即申请内存，这就是今天需要探索的内容，其实探索的本质也是为了验证 ios中对象中实际的对齐方式是8字节对齐 objc4中分析calloc 源码 首先从alloc进入objc的源码，找到obj = (id)calloc(1, size);操作，涉及的方法顺序是alloc --> _objc_rootAlloc --> callAlloc -->
malloc源码分析(2)--常用的常量&&变量&&方法
azraelxuemo的博客
03-13 861
文章目录SIZE_SZDEFAULT_MXFASTget_max_fastMALLOC_ALIGN_MASKNBINSNSMALLBINSMIN_LARGE_SIZEin_smallbin_range 在glibc源码学习里面有时候会遇见一些#define ，当我们先大概知道一些会在调试的时候更轻松 [未完待续] SIZE_SZ 这个其实就是用来判断你当前运行环境是32位还是64位的，变化的长度 32位是4 64位是8 #define INTERNAL_SIZE_T size_t #define SIZE_
iOS内存管理和malloc源码解读
weixin_33767813的博客
01-21 260
最近由于排查问题，顺便对iOS的内存管理，尤其是malloc库稍微深入地了解一下，在这里整理出来，和大家分享一下。 0. iOS内存基本原理 在接触iOS开发的时候，我们都知道“引用计数”的概念，也知道ARC和MRR，但其实这仅仅是对堆内存上对象的内存管理。用WWDC某Session里的话说，这其实只是内存管理的冰山一角。 在内存管理方面，其实iOS和其...
iOS中malloc后内存不下降
LDSleidisen的博客
11-06 959
最近遇到个问题：在app初始化的时候，做了一件事，从plist中读取数据，然后通过递归调用自定义的方法进行数据转Model，一切看起来都正常不过。 可是当我的数据比较复杂，递归的次数多的时候，就会发现明显加载速度变慢了，可是这种情况只会发生在初次加载的时候，也就是说当我这个界面返回到上个界面（本界面已经malloc了）的时候，再次进入，会发现界面比第一次块的不是一点半点。 明明都已经mallo
malloc和calloc区别
01-03
malloc和calloc区别 函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。 malloc()函数有一个参数,即要分配的内存空间的大小: void *malloc(size_t size); calloc()函数有两个参数,分别为元素...
xin\malloc和calloc区别
12-11
xin\malloc和calloc区别,经典归纳
利用数组模拟C语言malloc/calloc
06-20
利用C语言进行模拟实现calloc/malloc的方程，可以更好的学习C语言内存管理，
Vue指令、生命周期、Axios异步请求方式
NeilNiu
04-28 799
Vue 是一款用于构建用户界面的的JavaScript框架。
常用的启发式算法
Code掘金的博客
04-28 843
启发式算法是一类灵活而强大的优化算法，适用于各种复杂的优化问题。选择合适的启发式算法并结合具体问题特点进行调优，可以有效地解决实际应用中的各种优化挑战。
iOS 模拟请求 （本地数据调试）
sgliquangang的专栏
04-28 1344
APP代码已编写完成，但后台的接口还无法使用，这时 APP开发就可能陷入停滞。此时iOS 模拟请求就派上用场了，使用模拟请求来调试代码，如果调试都通过了，等后台接口可用时，基本只需调通即可完成几乎所有APP开发工作，这样APP开发人员的开发不会浪费时间，开发节奏和质量都得到保证本文章使用青花瓷（charles）为读者介绍模拟调试的正确姿势，如果没有安装，请百度之参考文章使用Mac自带的apache制作测试假数据使用青花瓷的Map local功能方式请求假数据。
[iOS]APP优化
Gamin
04-27 1117
性能优化是一个至关重要的过程，它对提高应用的用户体验、增强应用的市场竞争力以及维持用户的长期参与度具有深远的影响。
【iOS】方法交换(Method Swizzling)
最新发布
weixin_72437555的博客
05-03 812
上文讲到了iOS的消息发送机制，在消息机制中我们了解到了SEL、IMP等方法知识，由此延伸到iOS黑魔法方法交换，本篇着重讲解iOS的方法交换的应用场景与原理这篇文章主要总结了的各种应用场景，例如防止按钮被多次点击，进行hook操作以及数组与KVO的兜底操作，应用场景非常广泛，值得深入学习iOS Crash防护系统-IronManiOS KVO 崩溃防护笔记。
[iOS]使用CocoaPods发布公开库
Gamin
04-27 1636
在 podspec 文件中使用标签，通常意味着你指定了一个稳定的、用于发布的版本。这是最常见的用法，因为这确保了项目的依赖是固定且可预测的。这通常用于开发阶段，当你想要使用最新的尚未发布的代码时。标签是静态的，指向特定的提交，不会随着更多的提交而变化。选择库名时，尽量选择具有描述性并且独特的名字，这不仅可以避免命名冲突，还可以帮助用户更好地理解库的用途和功能。文件，在编辑器中进行修改，以符合你的库的具体情况。将你的项目推送到一个 Git 仓库（如 GitHub），确保为发布的版本创建相应的分支或者标签。
malloc和calloc
05-26
`malloc` 和 `calloc` 都是用于动态分配内存空间的函数。 `malloc` 函数的原型如下： ```c void* malloc(size_t size); ``` 它接受一个参数 `size`，表示要分配的内存空间大小（以字节为单位），并返回一个指向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值