Linux内存管理(六): 分配物理内存alloc_pages

最新推荐文章于 2024-07-05 00:49:10 发布
最新推荐文章于 2024-07-05 00:49:10 发布
阅读量1w 收藏 48
点赞数 4
分类专栏： 内存管理 文章标签： alloc_pages gfp_mask slowpath fastpath
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhb1047818384/article/details/112298996
版权

基于Linux 5.10, 体系结构是aarch64

上文介绍了linux对物理内存的描述，本篇介绍linux下物理页面的分配函数alloc_pages

1.API接口

alloc_pages是内核中常用的分配物理内存页面的函数， 函数定义在[include/linux/gfp.h]， 用于分配2^order 个连续的物理页。

#ifdef CONFIG_NUMA
static inline struct page * alloc_pages(gfp_t gfp_mask, unsigned int order)
{
	return alloc_pages_current(gfp_mask, order);
}
#else
static inline struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
{
	return alloc_pages_node(numa_node_id(), gfp_mask, order);
}
#endif

除了alloc_pages, linux内核还提供了另一个获取page frame的基本函数__get_free_pages

unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);

两者参数一样，但是返回值不同，__get_free_pages()比alloc_pages()多了一个地址转换的工作。
alloc_pages()返回指向第一个page的struct page指针，__get_free_pages()返回第一个page映射后的虚拟地址。

2.参数说明

gfp_mask: 分配掩码

定义在include/linux/gfp.h
gfp的全称是get free page， 因此gfp_mask表示页面分配的方法。
为了兼容多种内存分配的场景，gfp_mask主要分为以下几类：

1. 内存管理区修饰符 (zone modifiers)
内存管理区修饰符主要描述从哪些内存管理区来分配内存

flagdescription
__GFP_DMA从ZONE_DMA区中分配内存                                   
__GFP_HIGNMEM从ZONE_HIGHMEM区中分配内存
__GFP_DMA32从ZONE_DMA32区中分配内存
__GFP_MOVABLE内存规整时可以迁移或回收页面

2. 移动和替换修饰符(mobility and placement modifiers)
移动和替换修饰符主要表示分配出来的页面具有的迁移属性

flagdescription
__GFP_RECLAIMABLE分配的内存页面可以回收                                                               
__GFP_WRITE申请的页面会被弄成脏页
__GFP_HARDWALL强制使用cpuset内存分配策略
__GFP_THISNODE在指定的节点上分配内存
__GFP_ACCOUNTkmemcg会记录分配过程

3. 水位修饰符 （watermark modifiers）

flagdescription
__GFP_ATOMIC高优先级分配内存，分配器可以分配最低警戒水位线下的预留内存
__GFP_HIGH分配内存的过程中不可以睡眠或执行页面回收动作
__GFP_MEMALLOC允许访问所有的内存
__GFP_NOMEMALLOC不允许访问最低警戒水位线下的系统预留内存

4. 页面回收修饰符（reclaim modifiers)

flagdescription
__GFP_IO启动物理I/O传输
__GFP_FS允许调用底层FS文件系统。可避免分配器递归到可能已经持有锁的文件系统中， 避免死锁
__GFP_DIRECT_RECLAIM               分配内存过程中可以使用直接内存回收
__GFP_KSWAPD_RECLAIM内存到达低水位时唤醒kswapd线程异步回收内存
__GFP_RECLAIM表示是否可以直接内存回收或者使用kswapd线程进行回收
__GFP_RETRY_MAYFAIL分配内存可以可能会失败，但是在申请过程中会回收一些不必要的内存，是整个系统受益
__GFP_NOFAIL内存分配失败后无限制的重复尝试，知道分配成功
__GFP_NORETRY直接页面回收或者内存规整后还是无法分配内存时，不启用retry反复尝试分配内存，直接返回NULL

5. 行为修饰符 (action modifiers)

flagdescription
__GFP_NOWARN关闭内存分配过程中的WARNING
__GFP_COMP分配的内存页面将被组合成复合页compound page
__GFP_ZERO返回一个全部填充为0的页面

6. 组合类型标志(Useful GFP flag combinations)
前面描述的修饰符种过于繁多，因此linux定义了一些组合的类型标志，供开发者使用。

flagelementdescription
GFP_ATOMIC__GFP_HIGH |__GFP_ATOMIC
|__GFP_KSWAPD_RECLAIM		分配过程不能休眠，分配具有高优先级，可以访问系统预留内存
GFP_KERNEL__GFP_RECLAIM |__GFP_IO
|__GFP_FS		分配内存时可以被阻塞(即休眠)
GFP_KERNEL_ACCOUNTGFP_KERNEL |__GFP_ACCOUNT和GFP_KERNEL作用一样，但是分配的过程会被kmemcg记录
GFP_NOWAIT__GFP_KSWAPD_RECLAIM分配过程中不允许因直接内存回收而导致停顿
GFP_NOIO__GFP_RECLAIM不需要启动任何的I/O操作
GFP_NOFS__GFP_RECLAIM |__GFP_IO不会有访问任何文件系统的操作
GFP_USER__GFP_RECLAIM |__GFP_IO
|__GFP_FS |__GFP_HARDWALL		用户空间的进程分配内存
GFP_DMA__GFP_DMA从ZONE_DMA区分配内存
GFP_DMA32__GFP_DMA32从ZONE_DMA32区分配内存
GFP_HIGHUSERGFP_USER | __GFP_HIGHMEM用户进程分配内存，优先使用ZONE_HIGHMEM， 且这些页面不允许迁移
GFP_HIGHUSER_MOVABLEGFP_HIGHUSER | __GFP_MOVABLE和GFP_HIGHUSER类似，但是页面可以迁移
GFP_TRANSHUGE_LIGHTGFP_HIGHUSER_MOVABLE
| __GFP_COMP | __GFP_NOMEMALLOC
| __GFP_NOWARN) & ~__GFP_RECLAIM		透明大页的内存分配， light表示不进行内存压缩和回收
GFP_TRANSHUGEGFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM和GFP_TRANSHUGE_LIGHT类似，通常khugepaged使用该标志

note: GFP_KERNEL是最常见使用的标志，需要注意的是该标志会引起休眠，所以避免在中断上下文使用该标志来分配内存

order: 分配级数

页面分配器使用伙伴系统按照顺序请求页面分配。所以只能以2的幂内存分配。例如，请求order=3的页面分配，最终会分配2 ^ 3 = 8页。
arm64当前默认MAX_ORDER为11， 即最多一次性分配2 ^（MAX_ORDER-1）个页

/* Free memory management - zoned buddy allocator.  */
#define MAX_ORDER 11

3.内核实现

从上面函数的定义来看，在NUMA和UMA的内存架构下，函数的实现有区别
在这里插入图片描述

alloc_pages_current

在NUMA内存架构下，会调用到alloc_pages_current()函数
如上图所示，该函数主要有2个动作：

  1. 如果当前是__GFP_THISNODE标志 限制为本地节点， 则使用默认内存策略； 如果当前处于中断上下文，也使用默认内存分配策略（本地节点）
  2. 获取当前NUMA的内存分配策略， 如果当前的策略是MPOL_INTERLEAVE， 说明需要跨节点分配内存，就会走alloc_page_interleave()分支； 反之，则按默认的方式分配内存，即在当前的节点分配内存，就和UMA的流程一致了。

NUMA的内存分配策略定义在[include/uapi/linux/mempolicy.h]

enum {
	MPOL_DEFAULT,
	MPOL_PREFERRED,
	MPOL_BIND,
	MPOL_INTERLEAVE,
	MPOL_LOCAL,
	MPOL_MAX,	/* always last member of enum */
};

MPOL_PREFERRED： 从preferred节点分配内存，如果分配不到再选择其他node
MPOL_BIND：从绑定的1个或多个节点上分配内存
MPOL_INTERLEAVE：在所有可满足需求的节点上交叉分配上分配内存。
MPOL_LOCAL： 从本地节点上分配内存

__alloc_pages_nodemask

the ‘heart’ of the zoned buddy allocator“ .
该函数是内存分配的核心，无论是UMA架构或者NUMA架构都会调用到这里。
__alloc_pages_nodemask()主要执行以下步骤：
1. prepare_alloc_pages()
初始化页面分配器中会用到的参数，这些参数会临时存放在alloc_context数据结构中

struct alloc_context {
	struct zonelist *zonelist;
	nodemask_t *nodemask;
	struct zoneref *preferred_zoneref;
	int migratetype;
	enum zone_type high_zoneidx;
	bool spread_dirty_pages;
};

zonelist：指向用于分配页面的区域列表；
nodemask：指定内存分配的Node，如果没有指定，则在所有节点中进行分配；
preferred_zone：指定要在快速路径中首先分配的区域，在慢路径中指定了zonelist中的第一个可用区域；
migratetype：页面迁移类型；
high_zoneidx：允许内存分配的最高zone；
spread_dirty_pages：指定是否进行脏页的传播；

2. alloc_flags_nofragment()
根据区域和gfp掩码请求添加分配标志

static inline unsigned int
alloc_flags_nofragment(struct zone *zone, gfp_t gfp_mask)
{
	unsigned int alloc_flags;

	alloc_flags = (__force int) (gfp_mask & __GFP_KSWAPD_RECLAIM);   --------- （1）
#ifdef CONFIG_ZONE_DMA32
	if (!zone)
		return alloc_flags;

	if (zone_idx(zone) != ZONE_NORMAL)
		return alloc_flags;

	BUILD_BUG_ON(ZONE_NORMAL - ZONE_DMA32 != 1);
	if (nr_online_nodes > 1 && !populated_zone(--zone))
		return alloc_flags;

	alloc_flags |= ALLOC_NOFRAGMENT;                           ------------ (2)
#endif /* CONFIG_ZONE_DMA32 */
	return alloc_flags;
}

(1) 如果gfp_mask限定了使用__GFP_KSWAPD_RECLAIM， 则在alloc标志中添加ALLOC_KSWAPD， 在内存不足时以唤醒kswapd
(2) ZONE_DMA32分配内存时，增加一个alloc标志位ALLOC_NOFRAGMENT， 表示需要避免碎片化。

alloc_flags主要是函数内部使用，gfp_to_alloc_flags()函数可以根据gfp_mask对alloc flags进行调整
更多的alloc flags定义在[mm/internal.h]

#define ALLOC_WMARK_MIN		WMARK_MIN
#define ALLOC_WMARK_LOW		WMARK_LOW
#define ALLOC_WMARK_HIGH	WMARK_HIGH
#define ALLOC_NO_WATERMARKS	0x04 /* don't check watermarks at all */
#define ALLOC_OOM		ALLOC_NO_WATERMARKS
#define ALLOC_HARDER		 0x10 /* try to alloc harder */
#define ALLOC_HIGH		 0x20 /* __GFP_HIGH set */
#define ALLOC_CPUSET		 0x40 /* check for correct cpuset */
#define ALLOC_CMA		 0x80 /* allow allocations from CMA areas */
#define ALLOC_NOFRAGMENT	0x100 /* avoid mixing pageblock types */
#define ALLOC_KSWAPD		0x800 /* allow waking of kswapd, __GFP_KSWAPD_RECLAIM set */

ALLOC_WMARK_MIN：仅在最小水位water mark及以上限制页面分配；
ALLOC_WMARK_LOW：仅在低水位water mark及以上限制页面分配；
ALLOC_WMARK_HIGH：仅在高水位water mark及以上限制页面分配；
ALLOC_NO_WATERMARKS: 页面分配时不检查水位
ALLOC_HARDER: 尽力分配，一般在gfp_mask设置了__GFP_ATOMIC时会使用。如果页面分配失败，则尽可能分配MIGRATE_HIGHATOMIC类型的空闲页面。
ALLOC_HIGH：高优先级分配，一般在gfp_mask设置了__GFP_HIGH时使用
ALLOC_CPUSET：检查是否为正确的cpuset；
ALLOC_CMA： 允许从CMA区域进行分配
ALLOC_KSWAPD: 内存不足时唤醒kswapd内核线程

3. get_page_from_freelist
该函数的主要作用是从空闲页面链表中尝试分配内存，是内存分配的fastpath, 流程如下图所示：
在这里插入图片描述
(1) 从preferred zone开始遍历zonelist, 这里使用的是for_next_zone_zonelist_nodemask宏来遍历。 需要注意的是扫描zone的方向是从高端zone到低端zone； preferred zone是通用first_zones_zonelist计算得到的。
(2)判断该zone是否满足分配需求，如果zone空间不足，则进行node_reclaim(), 尝试页面回收
(3)如果回收后的空间满足要求，则调用rmqueue()从伙伴系统中进行内存分配。分配成功则返回page.

4. __alloc_pages_slowpath
如果快速路径分配内存失败了，则跳转到该函数进行慢速路径的内存分配。 流程如下图所示：
在这里插入图片描述

慢速路径的内存分配比较复杂：

static inline struct page *
__alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
						struct alloc_context *ac)
{
	bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
	const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
	struct page *page = NULL;

retry_cpuset:
	compaction_retries = 0;
	no_progress_loops = 0;
	compact_priority = DEF_COMPACT_PRIORITY;
	cpuset_mems_cookie = read_mems_allowed_begin();

	alloc_flags = gfp_to_alloc_flags(gfp_mask);                  -------------------- （1）
	ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,              -------------------- （2）
					ac->highest_zoneidx, ac->nodemask);
	if (!ac->preferred_zoneref->zone)
		goto nopage;

	if (alloc_flags & ALLOC_KSWAPD)
		wake_all_kswapds(order, gfp_mask, ac);                       ---------------------- （3）

	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);          --------------- （4）
	if (page)
		goto got_pg;

	if (can_direct_reclaim &&
			(costly_order ||
			   (order > 0 && ac->migratetype != MIGRATE_MOVABLE))
			&& !gfp_pfmemalloc_allowed(gfp_mask)) {
		page = __alloc_pages_direct_compact(gfp_mask, order,            ----------------- （5）
						alloc_flags, ac,
						INIT_COMPACT_PRIORITY,
						&compact_result);
		if (page)
			goto got_pg;
		if (costly_order && (gfp_mask & __GFP_NORETRY)) {

			if (compact_result == COMPACT_SKIPPED ||
			    compact_result == COMPACT_DEFERRED)
				goto nopage;

			compact_priority = INIT_COMPACT_PRIORITY;
		}
	}

（1） 通过gfp_to_alloc_flags(), 根据gfp_mask对内存分配标识进行调整
（2）通过first_zones_zonelist()重新计算preferred zone； 因为可能在fastpath中使用的nodemask不同，或者cpuset进行了修改，正在retry, 这样需要重新计算preferred zone，以免无限的遍历不符合要求的zone
（3） 如果alloc_flag标志ALLOC_KSWAPD， 那么会通过wake_all_kswapds唤醒kswapd内核线程
（4）使用调整后的标志来尝试第一次慢速路径内存分配，分配的函数也是get_page_from_freelist
（5）如果分配失败，满足“允许直接回收内存（can_direct_reclaim）” 或者 "不适用pfmemalloc的内存分配请求"等条件，将会进行一次内存的压缩并分配页面

如果上面的分配都失败了，会进行retry操作。

retry:
	if (alloc_flags & ALLOC_KSWAPD)
		wake_all_kswapds(order, gfp_mask, ac);                ---------------------- (1)

	reserve_flags = __gfp_pfmemalloc_flags(gfp_mask);
	if (reserve_flags)
		alloc_flags = current_alloc_flags(gfp_mask, reserve_flags);

	if (!(alloc_flags & ALLOC_CPUSET) || reserve_flags) {
		ac->nodemask = NULL;
		ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,             
					ac->highest_zoneidx, ac->nodemask);
	}

	/* Attempt with potentially adjusted zonelist and alloc_flags */
	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);  --------------- (2)
	if (page)
		goto got_pg;

	/* Caller is not willing to reclaim, we can't balance anything */
	if (!can_direct_reclaim)                              ------------------------- (3)
		goto nopage;

	/* Avoid recursion of direct reclaim */
	if (current->flags & PF_MEMALLOC)
		goto nopage;

	/* Try direct reclaim and then allocating */
	page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
							&did_some_progress);          ----------------------- (4)
	if (page)
		goto got_pg;

	/* Try direct compaction and then allocating */
	page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
					compact_priority, &compact_result);            ------------------ (5)
	if (page)
		goto got_pg;

	/* Do not loop if specifically requested */
	if (gfp_mask & __GFP_NORETRY)
		goto nopage;

	if (costly_order && !(gfp_mask & __GFP_RETRY_MAYFAIL))
		goto nopage;

	if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
				 did_some_progress > 0, &no_progress_loops))        --------------------- (6)
		goto retry;


	if (did_some_progress > 0 &&
			should_compact_retry(ac, order, alloc_flags,                ------------------- (7)
				compact_result, &compact_priority,
				&compaction_retries))
		goto retry;


	/* Deal with possible cpuset update races before we start OOM killing */
	if (check_retry_cpuset(cpuset_mems_cookie, ac))         ------------------- （8）
		goto retry_cpuset;

	/* Reclaim has failed us, start killing things */
	page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);  ----------------- (9)
	if (page)
		goto got_pg;

	/* Avoid allocations with no watermarks from looping endlessly */
	if (tsk_is_oom_victim(current) &&                            ----------------------- (10)
	    (alloc_flags & ALLOC_OOM ||
	     (gfp_mask & __GFP_NOMEMALLOC)))
		goto nopage;

	/* Retry as long as the OOM killer is making progress */
	if (did_some_progress) {
		no_progress_loops = 0;
		goto retry;
	}

（1） retry 的过程中会重新唤醒kswapd线程(防止意外的休眠)
（2）调整zone后通过get_page_from_freelist 重新进行内存分配
（3） 如果分配失败了，并且不能够直接内存回收， 就跳转到"no_page"
（4）__alloc_pages_direct_reclaim()尝试直接内存回收后分配页面
(5) __alloc_pages_direct_compact()进行第二次直接内存压缩后分配页面
(6) should_reclaim_retry()会判断是否需要重新回收，然后调转到“retry”. 如果gfp_mask中有noretry标志或者__GFP_RETRY_MAYFAIL标志，那么不会重新retry, 直接跳转到"no_page"
(7) should_compact_retry()会判断是否需要重新压缩，然后跳转到”retry"
(8)check_retry_cpuset(), 如果检测到由于cpuset发生变化而检测到竞争条件，跳转到最开始的"retry_cpuset"
(9) __alloc_pages_may_oom(), 如果内存回收失败，会尝试进行oom kill 一些进程，进行内存的回收
(10) 如果当前task由于OOM而处于被杀死的状态，则跳转移至“nopage”

“no_page”标签主要是对slowpath最后的补充处理


nopage:
	/* Deal with possible cpuset update races before we fail */
	if (check_retry_cpuset(cpuset_mems_cookie, ac))             
		goto retry_cpuset; 
	if (gfp_mask & __GFP_NOFAIL) {                      -------------------- （1）
		if (WARN_ON_ONCE(!can_direct_reclaim))
			goto fail;
		WARN_ON_ONCE(current->flags & PF_MEMALLOC);
		WARN_ON_ONCE(order > PAGE_ALLOC_COSTLY_ORDER);
		page = __alloc_pages_cpuset_fallback(gfp_mask, order, ALLOC_HARDER, ac);  ----------------- （2）
		if (page)
			goto got_pg;
		cond_resched();
		goto retry;
	}
fail:
	warn_alloc(gfp_mask, ac->nodemask,
			"page allocation failure: order:%u", order);
got_pg:
	return page;
}

(1) 如果gfp_mask标志位有nofail选项，则将重试直到分配到页面为止； 如果没有该标志，说明page没有分配成功，直接返回NULL
(2)__alloc_pages_cpuset_fallback(), 使用ALLOC_HARDER标志，如果节点耗尽，则回退以忽略cpuset的限制。

4.小结

页面分配几乎涉及到内存管理的所有的知识点，本篇只是浅尝辄止的描述了gfp_mask分配掩码, alloc_flag分配标志, 快速分配和慢速分配的流程，其他涉及到的如伙伴系统，水线，页面回收，页面规整以及oom killer放到以后再进行分析。

5.参考资料

http://jake.dothome.co.kr/zonned-allocator-alloc-pages-fastpath/

Hober_yao
关注
专栏目录
Linux内存管理（三十三）：slub 分配器之__kmem_cache_create
私房菜
11-16 1014
是数据结构 kmem_cache 创建的核心函数，无论是在slab 初始化期间，还是在用户层调用 kmem_cache_create() 创建slab 描述符时，都离不开这个核心函数。为了减少slab 初始化和 kmem_cache_create() 博文的繁琐，我们将该函数单独提出来剖析。本文重点分析slub 分配器中 __kmem_cache_create() 的实现过程。
alloc_page分配内存
m0_74282605的博客
01-14 670
_get_free_pages调用alloc_pages完成内存分配, 而alloc_pages又借助于alloc_pages_node，__get_free_pages函数的定义在mm/page_alloc.c。alloc_flags和gfp_mask之间的区别，gfp_mask是使用alloc_pages申请内存时所传递的申请标记，而alloc_flags是在内存管理子系统内部使用的另一个标记。函数直接将自己的所有信息传递给__alloc_pages_nodemask来完成内存的分配。
[内核内存] 伙伴系统4---alloc_pages(内存块分配)
菁的博客
04-19 3054
文章目录alloc_pages源码流程分析alloc_pages函数实现流程代码细节分析**参数准备****核心函数__alloc_pages_nodemask**快速内存分配（get_page_from_freelist)get_page_from_freelist流程图get_page_from_freelist代码实现细节慢速内存分配(\_\_alloc_pages_slowpath())\_\_alloc_pages_slowpath函数流程图\_\_alloc_pages_slowpath代码实现
Linux内核管理之分配掩码（三）_gfp_mask
最新发布
m0_61408947的博客
07-05 440
在Linux2.6.24内核中，为了解决外碎片化的问题，引入了迁移类型，因此在分配内存时也需要指定所分配的页面具有哪些移动属性。对于内核开发者或者驱动开发者来说，要正确使用这些标志位是一件很困难的事情，因此定义了一些常用的分配掩码的组合，成为。16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?15、讲述一下LVS三种模式的工作过程?
Buddy system之alloc_pages
liuhangtiant的博客
07-15 715
申请pages的基础知识在“Buddy system基础 ”这篇文章中已经讲过了，这里主要分析申请pages的代码。 代码框架 alloc_pages //alloc_pages_node(numa_node_id(), gfp_mask, order) |----->return __alloc_pages_node(nid, gfp_mask, order); |...
Linux内存子系统——分配物理页面（alloc_pages）
深海
08-22 4866
Linux内存子系统——分配物理页面（alloc_pages）分配页面   内核中常用的分配物理内存页面的接口函数是alloc_pages()，用于分配一个或多个连续的物理页面，分配的页面个数只能是2的整数次幂。   诸如vmalloc、get_user_pages、以及缺页中断中分配页面，都是通过该接口分配的物理页面。 分配页面   alloc_pages函数有两个参数，一个是分配掩码gfp_mask，另一个是分配阶数order。 [include/linux/gfp.h] #define alloc_p
alloc_page分配内存空间--Linux内存管理(十七)
热门推荐
OSKernelLAB(gatieme)
09-29 2万+
日期 内核版本 架构 作者 GitHub CSDN 2016-09-29 Linux-4.7 X86 & arm gatieme LinuxDeviceDrivers Linux内存管理 1 前景回顾在内核初始化完成之后, 内存管理的责任就由伙伴系统来承担. 伙伴系统基于一种相对简单然而令人吃惊的强大算法.Linux内核使用二进制伙伴算法来管理和分配物理内
内存管理-alloc_pages()函数分配内存
qq_43084535的博客
01-12 1722
前言 Linux对页面分配分快速和慢速两种方法。在__alloc_pages_nodemask函数中，首先会使用快速方法进行内存分配，当分配失败时会进入慢速路径，函数最终会返回申请到的内存第一个页面page。本文主要对内存分配中的快速方法所涉及到的重要函数进行分析。 alloc_pages() 这个函数是内存分配的入口函数，最终会调用__alloc_pages_nodemask函数，关于内存分配的所以内容都会在这个函数中实现。它在mm/page_alloc.c中实现如下： struct page * __a
linux内存管理（四）源码解析之伙伴系统alloc_pages/free_pages
jkzzxQQQ的博客
12-27 959
本文kernel代码分析基于以下 1.linux-4.14.159 2.64bit代码处理逻辑 3.UMA架构 上一节伙伴系统详细介绍了伙伴系统的原理以及描述了页申请和释放的过程，另外对伙伴系统及涉及的一些概念进行了介绍，理解这些后我们来看代码中具体的申请流程和释放流程。 alloc_pages linux内核伙伴系统中分配物理内存常用的接口是alloc_pages(),其它接口最终都会归到alloc_pages()，特点是分配页面的个数是2的整数幂，因此函数无需提供分配的size，只需指明两个参数 第一个
linux内核那些事之buddy(慢速申请内存__alloc_pages_slowpath)(5)
weixin_42730667的博客
03-22 1226
内核提供__alloc_pages_nodemask接口申请物理内存主要分为两个部分：快速申请物理内存get_page_from_freelist（inux内核那些事之buddy(快速分配get_page_from_freelist()）(3)）和慢速申请__alloc_pages_slowpath慢速申请内存部分两个部分如下图： 首先尝试快速申请内存get_page_from_freelist，在快速内存中如果当前水位wmark_pages满足要求则调用get_page_from_free_are.
Linux内存管理（二十四）：buddy 分配器之get_page_from_freelist
私房菜
08-16 600
在上一文中主要分析了buddy 分配器分配的入口处理函数 __alloc_pages_nodemask() 的处理流程，其中在函数主要用以出初始化分配上下文 alloc_context，包括high_zoneidx、zonelist、migratetype、和以及alloc_mask 和 alloc_flags。alloc_flags_nofragment() 函数用以进一步的对 alloc_flags 进行确定，包括 ALLOC_KSWAPD 和 ALLOC_NOFRAGMENT 标记。从上一文。
linux内核分配物理页面alloc_pages
软工电子行
08-20 183
linux内核分配物理页空间
linux伙伴系统接口alloc_page分析
weixin_39094034的博客
12-11 811
在内核中分配内存，最后要通过伙伴系统接口进行实际物理页面的分配，一个重要的接口便是alloc_page.本文介绍下alloc_page的主要流程，各个部分的执行。主要包含正常分配流程，当页面不足的时候的处理方式。先定位到核心调用 #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0) order是分配页面的阶，即2的指数个页面 #define alloc_pages(gfp_mask, order) \ alloc_pages_n
alloc_page函数浅析
m0_74282605的博客
02-03 201
147 if (unlikely(order >= MAX_ORDER)) /如果要求分配的页数大于MAX_ORDER就以失败告终，这里的MAX_ORDER指的是最大页面号，这里要注意的是对于伙伴算法，所分配的 页面的最大值为2^10，即1024个页面，这一点在伙伴算法中经常会使用到，所以这里的MAX_ORDER的值为11，也就是说如果order的值大于了10，即超出了最大值，那么就会以失败告终，直接以失败返回。//分配页面函数，这个函数比较复杂，所牵涉到的内容也比较多，尤其是进程方面的内容。
alloc_pages函数分析
qq_34160238的博客
04-05 181
所以分析的实现需要分析这个函数.
大白话函数调用过程
yanchendage的博客
12-01 541
寄存器： 先来看寄存器。CPU 本身只负责运算，不负责储存数据。数据一般都储存在内存之中，CPU 要用的时候就去内存读写数据。CPU 还自带了寄存器（register），用来储存最常用的数据。也就是说，那些最频繁读写的数据（比如循环变量），都会放在寄存器里面，CPU 优先读写寄存器，再由寄存器跟内存交换数据。 先对几个常用寄存器有点印象，具体的去百度这里不展开。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I8ffJWLL-1606480128875)(/uploads/s
Linux内存管理内核API函数alloc_pages( )
Tim的嵌入式之旅
06-24 4469
http://blog.163.com/chujb_chen/blog/static/10571112013392331217/函数功能描述：       alloc_pages( )函数以gfp_mask分配方式分配2的order次方（1<<order）个连续的物理页。 输入参数说明：       gfp_mask： 是分配标志，内核分配内存有多种方式，该参数告诉内核如何分配以及在哪...
alloc_pages的实现浅析
m0_74282605的博客
01-02 500
假设我们请求分配一个order=2，大小为4的页块，order的最大值是5。我们从order=5的area得到一个大小为32的页块。所以我们order5的页块分配到order=3和order=4的页块。这时，order2 order3 order4分别得到了大小为4,8和16的页块。get_page_from_freelist() 遍历整个 zonelist, 如果找到一个watermark满足要求的zone, 就在这个zone上调用 buffered_rmqueue.原文作者：dennis-wong。
cuDNN error: CUDNN_STATUS_ALLOC_FAILED
10-28
cuDNN error: CUDNN_STATUS_ALLOC_FAILED是指cuDNN库在分配内存时失败了。这可能是由于显存不足或者其他程序占用了显存导致的。解决方法包括减少batch size、使用更小的模型、释放其他程序占用的显存等。如果问题仍然存在，可以尝试升级显卡驱动或者cuDNN版本。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值