devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux伙伴系统原理-内存分配和释放_伙伴系统是一种内存分配算法，其特点是

作者：Gausst松鼠会 | 2024-03-07 13:55:43

赞

踩

伙伴系统是一种内存分配算法，其特点是

主要分析Linux伙伴系统算法，内存的分配和释放

１．伙伴系统简介

     Linux内核内存管理的一项重要工作就是如何在频繁申请释放内存的情况下，避免碎片的产生,

Linux采用伙伴系统解决外部碎片的问题，采用slab解决内 部碎片的问题.

伙伴算法（Buddy system）把所有的空闲页框分为11个块链表，每块链表中分布包含特定的连续页框地址空间，比如第0个块链表包含大小为2^0个连续的页框，第1个块链表中，每个链表元素包含2个页框大小的连续地址空间，….，第10个块链表中，每个链表元素代表4M的连续地址空间。每个链表中元素的个数在系统初始化时决定，在执行过程中，动态变化。伙伴算法每次只能分配2的幂次页的空间，比如一次分配1页，2页，4页，8页，…，1024页(2^10)等等，每页大小一般为4K，因此，伙伴算法最多一次能够分配4M的内存空间。

1.1.1 关键数据结构
struct zone {
    struct free_area    free_area[MAX_ORDER];
}
struct free_area {
    struct list_head    free_list[MIGRATE_TYPES];
    unsigned long        nr_free;
};

free_area共有MAX_ORDER个元素，其中第order个元素记录了2^order的空闲块，这些空闲块在free_list中以双向链表的形式组织起来，对于同等大小的空闲块，其类型不同，将组织在不同的free_list中，nr_free记录了该free_area中总共的空闲内存块的数量。MAX_ORDER的默认值为11，这意味着最大内存块的大小为2^10=1024个页框。对于同等大小的内存块，每个内存块的起始页框用于链表的节点进行相连，这些节点对应的着struct page中的lru域
struct page {
    struct list_head lru;        /* Pageout list, eg. active_list
                     * protected by zone->lru_lock !
                     */
}

1.1.2 迁移类型

不可移动页(Non-movable pages)：这类页在内存当中有固定的位置，不能移动。内核的核心分配的内存大多属于这种类型
可回收页(Reclaimable pages)：这类页不能直接移动，但可以删除，其内容页可以从其他地方重新生成，例如，映射自文件的数据属于这种类型，针对这种页，内核有专门的页面回收处理
可移动页:这类页可以随意移动，用户空间应用程序所用到的页属于该类别。它们通过页表来映射，如果他们复制到新的位置，页表项也会相应的更新，应用程序不会注意到任何改变。
当一个指定的迁移类型所对应的链表中没有空闲块时，将会按以下定义的顺序到其他迁移类型的链表中寻找

static int fallbacks[MIGRATE_TYPES][MIGRATE_TYPES-1] = {
    [MIGRATE_UNMOVABLE]   = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE,   MIGRATE_RESERVE },
    [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE,   MIGRATE_MOVABLE,   MIGRATE_RESERVE },
    [MIGRATE_MOVABLE]     = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_RESERVE },
    [MIGRATE_RESERVE]     = { MIGRATE_RESERVE,     MIGRATE_RESERVE,   MIGRATE_RESERVE }, /* Never used */
};

通过cat /proc/pagetypeinfo可以看到迁移类型和order的关系

1.2 内存的分配

　分配函数为alloc_pages，最终调用到__alloc_pages_nodemask

  1. struct page *
  2. __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
  3. 			struct zonelist *zonelist, nodemask_t *nodemask)
  4. {
  5. 	struct zoneref *preferred_zoneref;
  6. 	struct page *page = NULL;
  7. 	unsigned int cpuset_mems_cookie;
  8. 	int alloc_flags = ALLOC_WMARK_LOW|ALLOC_CPUSET|ALLOC_FAIR;
  9. 	gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
  10. 	struct alloc_context ac = {
  11.                 /*根据gfp_mask,找到合适的zone idx和migrate类型 */
  12. 		.high_zoneidx = gfp_zone(gfp_mask),
  13. 		.nodemask = nodemask,
  14. 		.migratetype = gfpflags_to_migratetype(gfp_mask),
  15. 	};
  16.  
  17. retry_cpuset:
  18. 	cpuset_mems_cookie = read_mems_allowed_begin();
  19.  
  20. 	/* We set it here, as __alloc_pages_slowpath might have changed it */
  21. 	ac.zonelist = zonelist;
  22.  
  23. 	/* Dirty zone balancing only done in the fast path */
  24. 	ac.spread_dirty_pages = (gfp_mask & __GFP_WRITE);
  25.  
  26. 	/*根据分配掩码,确认先从哪个zone分配 */
  27. 　　　　　　　/* The preferred zone is used for statistics later */
  28. 	preferred_zoneref = first_zones_zonelist(ac.zonelist, ac.high_zoneidx,
  29. 				ac.nodemask ? : &cpuset_current_mems_allowed,
  30. 				&ac.preferred_zone);
  31. 	if (!ac.preferred_zone)
  32. 		goto out;
  33. 	ac.classzone_idx = zonelist_zone_idx(preferred_zoneref);
  34.  
  35. 	/* First allocation attempt */
  36. 	alloc_mask = gfp_mask|__GFP_HARDWALL;
  37. 	/*快速分配 */
  38. 	page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
  39. 	if (unlikely(!page)) {
  40. 		/*慢速分配，涉及到内存回收，暂不分析 */
  41. 		page = __alloc_pages_slowpath(alloc_mask, order, &ac);
  42. 	}
  43.  
  44. out:
  45. 	if (unlikely(!page && read_mems_allowed_retry(cpuset_mems_cookie)))
  46. 		goto retry_cpuset;
  47.  
  48. 	return page;
  49. }

1.2.1 水位控制

   每个zone有三个水位(watermark),用以标识系统内存存量,由数组 watermark[NR_WMARK]表示.

WMARK_MIN，WMARK_LOW,WMARK_HIGH,当内存存量低于对应水位时，就会调用zone_reclaim()进行内存回收.

mark = zone->watermark[alloc_flags & ALLOC_WMARK_MASK];
        if (!zone_watermark_ok(zone, order, mark,//判断水位是否正常
                       ac->classzone_idx, alloc_flags)) {

            ret = zone_reclaim(zone, gfp_mask, order);
｝

1.2.2 单个页面的分配

get_page_from_freelist->buffered_rmqueue:

order=0时，单个页面直接从per cpu的free list分配，这样效率最高.

  1. if (likely(order == 0)) {
  2. 		struct per_cpu_pages *pcp;
  3. 		struct list_head *list;
  4. 		local_irq_save(flags);
  5. 		pcp = &this_cpu_ptr(zone->pageset)->pcp;
  6. 		list = &pcp->lists[migratetype];
  7. 		/*如果对应list为空，则从伙伴系统拿内存*/
  8. 		if (list_empty(list)) {
  9. 			pcp->count += rmqueue_bulk(zone, 0,
  10. 					pcp->batch, list,
  11. 					migratetype, gfp_flags);
  12. 			if (unlikely(list_empty(list)))
  13. 				goto failed;
  14. 		}
  15.  
  16. 		/*分配一个页面 */
  17. 　　　　　　　　　　　　　　　　if ((gfp_flags & __GFP_COLD) != 0)
  18. 			page = list_entry(list->prev, struct page, lru);
  19. 		else
  20. 			page = list_entry(list->next, struct page, lru);
  21.  
  22. 		if (!(gfp_flags & __GFP_CMA) &&
  23. 				is_migrate_cma(get_pcppage_migratetype(page))) {
  24. 			page = NULL;
  25. 			local_irq_restore(flags);
  26. 		} else {
  27. 			list_del(&page->lru);
  28. 			pcp->count--;
  29. 		}
  30. 	}

1.2.3 多个页面的分配(order>1)

get_page_from_freelist->buffered_rmqueue->__rmqueue:

  1. static struct page *__rmqueue(struct zone *zone, unsigned int order,
  2. 				int migratetype, gfp_t gfp_flags)
  3. {
  4. 	struct page *page = NULL;
  5.         /*CMA内存的分配 */
  6. 	if ((migratetype == MIGRATE_MOVABLE) && (gfp_flags & __GFP_CMA))
  7. 		page = __rmqueue_cma_fallback(zone, order);
  8.  
  9. 	if (!page)/*根据order和migrate type找到对应的freelist分配内存 */
  10. 		page = __rmqueue_smallest(zone, order, migratetype);
  11.  
  12. 	if (unlikely(!page))/*当对应的migrate type无法满足order分配时，进行fallback规则分配
  13. ，分配规则定义在fallbacks数组中。 */
  14. 		page = __rmqueue_fallback(zone, order, migratetype);
  15.  
  16. 	
  17. 	return page;
  18. }

这里分析migrate type能够满足内存分配的情况

static inline
struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
                        int migratetype)
{
    unsigned int current_order;
    struct free_area *area;
    struct page *page;

    /* 根据order，逐级向上查找*/
    for (current_order = order; current_order < MAX_ORDER; ++current_order) {
        area = &(zone->free_area[current_order]);
        if (list_empty(&area->free_list[migratetype]))
            continue;

        page = list_entry(area->free_list[migratetype].next,
                            struct page, lru);
        list_del(&page->lru);
        rmv_page_order(page);
        area->nr_free--;

　　/* 切蛋糕,如果current_order大于目标order,则要把多余的内存挂到对应的order链表.*/
        expand(zone, page, order, current_order, area, migratetype);
        set_pcppage_migratetype(page, migratetype);
        return page;
    }

    return NULL;
}

  1.  static inline void expand(struct zone *zone, struct page *page,
  2. 	int low, int high, struct free_area *area,
  3. 	int migratetype)
  4. {
  5. 	unsigned long size = 1 << high;//先一分为2
  6.  
  7. 	while (high > low) {
  8. 		area--;/* 回退到下一级链表*/
  9. 		high--;
  10. 		size >>= 1;/*Size减半 */
  11.                　/*接入下一级空闲链表 */
  12. 		list_add(&page[size].lru, &area->free_list[migratetype]);
  13. 		area->nr_free++;
  14. 		set_page_order(&page[size], high);
  15. 	}
  16. }

1.2.4 fallback分配

当前migrate　type不能满足内存分配需求时，需要到其他migrate type空闲链表分配内存.

规则如下：

static int fallbacks[MIGRATE_TYPES][4] = {
    [MIGRATE_UNMOVABLE]   = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE,   MIGRATE_TYPES },
    [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE,   MIGRATE_MOVABLE,   MIGRATE_TYPES },
    [MIGRATE_MOVABLE]     = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
#ifdef CONFIG_CMA
    [MIGRATE_CMA]         = { MIGRATE_TYPES }, /* Never used */
#endif
#ifdef CONFIG_MEMORY_ISOLATION
    [MIGRATE_ISOLATE]     = { MIGRATE_TYPES }, /* Never used */
#endif
};

  1. __rmqueue_fallback(struct zone *zone, unsigned int order, int start_migratetype)
  2. {
  3. 	struct free_area *area;
  4. 	unsigned int current_order;
  5. 	struct page *page;
  6. 	int fallback_mt;
  7. 	bool can_steal;
  8.  
  9. 	/* 先从最大的order list中找到合适的块 */
  10. 	for (current_order = MAX_ORDER-1;
  11. 				current_order >= order && current_order <= MAX_ORDER-1;
  12. 				--current_order) {
  13. 		area = &(zone->free_area[current_order]);
  14. 		/*从fallbacks数组中找到合适的migrate type链表 */
  15. 		fallback_mt = find_suitable_fallback(area, current_order,
  16. 				start_migratetype, false, &can_steal);
  17. 		if (fallback_mt == -1)
  18. 			continue;
  19.  
  20. 		page = list_entry(area->free_list[fallback_mt].next,
  21. 						struct page, lru);
  22. 		if (can_steal &&/*改变pageblock的migrate type */
  23. 			get_pageblock_migratetype(page) != MIGRATE_HIGHATOMIC)
  24. 			steal_suitable_fallback(zone, page, start_migratetype);
  25.  
  26. 		/* Remove the page from the freelists */
  27. 		area->nr_free--;
  28. 		list_del(&page->lru);
  29. 		rmv_page_order(page);
  30. 		/*切蛋糕 */
  31. 		expand(zone, page, order, current_order, area,
  32. 					start_migratetype);
  33.  
  34. 		set_pcppage_migratetype(page, start_migratetype);
  35.  
  36. 		trace_mm_page_alloc_extfrag(page, order, current_order,
  37. 			start_migratetype, fallback_mt);
  38.  
  39. 		return page;
  40. 	}
  41.  
  42. 	return NULL;
  43. }

如UNMOVABLE链表内存不足时，优先从RECLAIMABLE链表分配，再从MOVABLE链表分配

1.3 内存的释放

页面的释放，最终调用到__free_one_page函数.

首先两块内存是伙伴块,必须满足以下条件:

1. 伙伴不能在空洞页面中，要有实实在在的物理页面/the buddy is not in a hole/
2. 伙伴块在伙伴系统中，也就是伙伴块要是空闲的，没有被分配出去的内存块/the buddy is in the buddy system/
3. 要有相同的order /a page and its buddy have the same order/
4. 位于同一个zone./a page and its buddy are in the same zone/
5. 物理上要相连.且两个page的起始pfn号一定相差2^order，则有计算公式B2 = B1 ^ (1 << O)
static inline unsigned long
__find_buddy_index(unsigned long page_idx, unsigned int order)
{
    return page_idx ^ (1 << order);//计算buddy page的index
}

  1. static inline void __free_one_page(struct page *page,
  2. 		unsigned long pfn,
  3. 		struct zone *zone, unsigned int order,
  4. 		int migratetype)
  5. {
  6. 	unsigned long page_idx;
  7. 	unsigned long combined_idx;
  8. 	unsigned long uninitialized_var(buddy_idx);
  9. 	struct page *buddy;
  10. 	unsigned int max_order;
  11.  
  12. 	max_order = min_t(unsigned int, MAX_ORDER, pageblock_order + 1);
  13.  
  14. 	/*计算page_idx, */
  15. 	page_idx = pfn & ((1 << MAX_ORDER) - 1);
  16.  
  17. 	VM_BUG_ON_PAGE(page_idx & ((1 << order) - 1), page);
  18. 	VM_BUG_ON_PAGE(bad_range(zone, page), page);
  19.  
  20. continue_merging:
  21. 	while (order < max_order - 1) {
  22. 		/*找到buddy ix */
  23. 		buddy_idx = __find_buddy_index(page_idx, order);
  24. 		buddy = page + (buddy_idx - page_idx);
  25. 		/*判断是否是伙伴块 */
  26.                  if (!page_is_buddy(page, buddy, order))
  27. 			goto done_merging;
  28. 		/*
  29. 		 * Our buddy is free or it is CONFIG_DEBUG_PAGEALLOC guard page,
  30. 		 * merge with it and move up one order.
  31. 		 */
  32. 		if (page_is_guard(buddy)) {
  33. 			clear_page_guard(zone, buddy, order, migratetype);
  34. 		} else {
  35. 			list_del(&buddy->lru);
  36. 			zone->free_area[order].nr_free--;
  37. 			rmv_page_order(buddy);
  38. 		}
  39. 　　　　　　　　　　　　　　　 /*继续向上合并 */
  40. 		combined_idx = buddy_idx & page_idx;
  41. 		page = page + (combined_idx - page_idx);
  42. 		page_idx = combined_idx;
  43. 		order++;
  44. 	}
  45. 	
  46. done_merging:
  47. 	set_page_order(page, order);
  48.  
  49. 	/*
  50. 	 * If this is not the largest possible page, check if the buddy
  51. 	 * of the next-highest order is free. If it is, it's possible
  52. 	 * that pages are being freed that will coalesce soon. In case,
  53. 	 * that is happening, add the free page to the tail of the list
  54. 	 * so it's less likely to be used soon and more likely to be merged
  55. 	 * as a higher order page
  56. 	 */
  57. 	if ((order < MAX_ORDER-2) && pfn_valid_within(page_to_pfn(buddy))) {
  58. 		struct page *higher_page, *higher_buddy;
  59. 	        /*这里检查更上一级是否存在伙伴关系，如果是的,则把page添加到链表末尾，这样有利于页面回收. */
  60. 		combined_idx = buddy_idx & page_idx;
  61. 		higher_page = page + (combined_idx - page_idx);
  62. 		buddy_idx = __find_buddy_index(combined_idx, order + 1);
  63. 		higher_buddy = higher_page + (buddy_idx - combined_idx);
  64. 		if (page_is_buddy(higher_page, higher_buddy, order + 1)) {
  65. 			list_add_tail(&page->lru,
  66. 				&zone->free_area[order].free_list[migratetype]);
  67. 			goto out;
  68. 		}
  69. 	}
  70. 	/*链接到对应的free list 链表 */
  71. 	list_add(&page->lru, &zone->free_area[order].free_list[migratetype]);
  72. out:
  73. 	zone->free_area[order].nr_free++;
  74. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/206000
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号

        
cppcmd=keepalive&