Linux內存管理之伙伴系統

在內核初始化完成之后, 內存管理的責任就由伙伴系統來承擔. 伙伴系統基于一種相對簡單然而令人吃驚的強大算法.

Linux內核使用二進制伙伴算法來管理和分配物理內存頁面, 該算法由Knowlton設計, 后來Knuth又進行了更深刻的描述.

伙伴系統是一個結合了2的方冪個分配器和空閑緩沖區合并計技術的內存分配方案, 其基本思想很簡單. 內存被分成含有很多頁面的大塊, 每一塊都是2個頁面大小的方冪. 如果找不到想要的塊, 一個大塊會被分成兩部分, 這兩部分彼此就成為伙伴. 其中一半被用來分配, 而另一半則空閑. 這些塊在以后分配的過程中會繼續被二分直至產生一個所需大小的塊. 當一個塊被最終釋放時, 其伙伴將被檢測出來, 如果伙伴也空閑則合并兩者.

內核如何記住哪些內存塊是空閑的

分配空閑頁面的方法

影響分配器行為的眾多標識位

內存碎片的問題和分配器如何處理碎片

伙伴系統的結構

伙伴系統數據結構

系統內存中的每個物理內存頁（頁幀），都對應于一個struct page實例, 每個內存域都關聯了一個struct zone的實例，其中保存了用于管理伙伴數據的主要數數組

//  http://lxr.free-electrons.com/source/include/linux/mmzone.h?v=4.7#L324
struct zone
{
     /* free areas of different sizes */
    struct free_area        free_area[MAX_ORDER];
};


struct free_area是一個伙伴系統的輔助數據結構.
struct free_area {
    struct list_head        free_list[MIGRATE_TYPES];
    unsigned long           nr_free;
};

poYBAGJ_VpSADeheAAAcTLaol3s952.jpg?source=d16d100b

伙伴系統的分配器維護空閑頁面所組成的塊, 這里每一塊都是2的方冪個頁面, 方冪的指數稱為階.

階是伙伴系統中一個非常重要的術語. 它描述了內存分配的數量單位. 內存塊的長度是2^0,order , 其中order的范圍從0到MAX_ORDER

zone->free_area[MAX_ORDER]數組中階作為各個元素的索引, 用于指定對應鏈表中的連續內存區包含多少個頁幀.

數組中第0個元素的階為0, 它的free_list鏈表域指向具有包含區為單頁(2^0 = 1)的內存頁面鏈表

數組中第1個元素的free_list域管理的內存區為兩頁(2^1 = 2)

第3個管理的內存區為4頁, 依次類推.

直到 2^MAXORDER-1個頁面大小的塊

pYYBAGJ_VpSATroCAABeCpvGHmk265.jpg?source=d16d100b

最大階MAX_ORDER與FORCE_MAX_ZONEORDER配置選項

一般來說MAX_ORDER默認定義為11, 這意味著一次分配可以請求的頁數最大是2^11=2048.

/* Free memory management - zoned buddy allocator.  */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))

但如果特定于體系結構的代碼設置了FORCE_MAX_ZONEORDER配置選項, 該值也可以手工改變

例如，IA-64系統上巨大的地址空間可以處理MAX_ORDER = 18的情形，而ARM或v850系統則使用更小的值(如8或9). 但這不一定是由計算機支持的內存數量比較小引起的，也可能是內存對齊方式的要求所導致

可以參考一些架構的Kconfig文件如下

poYBAGJ_VpSASonbAAAO8KOh3Ho910.jpg?source=d16d100b

比如arm64體系結構的Kconfig配置文件的描述

config FORCE_MAX_ZONEORDER
int
default "14" if (ARM64_64K_PAGES && TRANSPARENT_HUGEPAGE)
default "12" if (ARM64_16K_PAGES && TRANSPARENT_HUGEPAGE)
default "11"

內存區是如何連接的

內存區中第1頁內的鏈表元素, 可用于將內存區維持在鏈表中。因此，也不必引入新的數據結構來管理物理上連續的頁，否則這些頁不可能在同一內存區中. 如下圖所示

pYYBAGJ_VpSAL-3VAABc7KxBXtU963.jpg?source=d16d100b

?
?

伙伴不必是彼此連接的. 如果一個內存區在分配其間分解為兩半, 內核會自動將未用的一半加入到對應的鏈表中.

如果在未來的某個時刻, 由于內存釋放的緣故, 兩個內存區都處于空閑狀態, 可通過其地址判斷其是否為伙伴. 管理工作較少, 是伙伴系統的一個主要優點.

基于伙伴系統的內存管理專注于某個結點的某個內存域, 例如, DMA或高端內存域. 但所有內存域和結點的伙伴系統都通過備用分配列表連接起來.

下圖說明了這種關系.

poYBAGJ_VpSAFfqMAACp7P_sqbM799.jpg?source=d16d100b

最后要注意, 有關伙伴系統和當前狀態的信息可以在/proc/buddyinfo中獲取

pYYBAGJ_VpWAVplFAAAbQEv0EoY629.jpg?source=d16d100b

內核中很多時候要求分配連續頁. 為快速檢測內存中的連續區域, 內核采用了一種古老而歷經檢驗的技術: 伙伴系統

系統中的空閑內存塊總是兩兩分組, 每組中的兩個內存塊稱作伙伴. 伙伴的分配可以是彼此獨立的. 但如果兩個伙伴都是空閑的, 內核會將其合并為一個更大的內存塊, 作為下一層次上某個內存塊的伙伴.

下圖示范了該系統, 圖中給出了一對伙伴, 初始大小均為8頁. 即系統中所有的頁面都是8頁的.

poYBAGJ_VpWAUiURAABgFQLnThY333.jpg?source=d16d100b

內核對所有大小相同的伙伴（1、2、4、8、16或其他數目的頁），都放置到同一個列表中管理. 各有8頁的一對伙伴也在相應的列表中.

如果系統現在需要8個頁幀, 則將16個頁幀組成的塊拆分為兩個伙伴. 其中一塊用于滿足應用程序的請求, 而剩余的8個頁幀則放置到對應8頁大小內存塊的列表中.

如果下一個請求只需要2個連續頁幀, 則由8頁組成的塊會分裂成2個伙伴, 每個包含4個頁幀. 其中一塊放置回伙伴列表中，而另一個再次分裂成2個伙伴, 每個包含2頁。其中一個回到伙伴系統，另一個則傳遞給應用程序.

在應用程序釋放內存時, 內核可以直接檢查地址, 來判斷是否能夠創建一組伙伴, 并合并為一個更大的內存塊放回到伙伴列表中, 這剛好是內存塊分裂的逆過程。這提高了較大內存塊可用的可能性.

在系統長期運行時，服務器運行幾個星期乃至幾個月是很正常的，許多桌面系統也趨向于長期開機運行，那么會發生稱為碎片的內存管理問題。頻繁的分配和釋放頁幀可能導致一種情況：系統中有若干頁幀是空閑的，但卻散布在物理地址空間的各處。換句話說，系統中缺乏連續頁幀組成的較大的內存塊，而從性能上考慮，卻又很需要使用較大的連續內存塊。通過伙伴系統可以在某種程度上減少這種效應，但無法完全消除。如果在大塊的連續內存中間剛好有一個頁幀分配出去，很顯然這兩塊空閑的內存是無法合并的.

在內核版本2.6.24之后, 增加了一些有效措施來防止內存碎片.

避免碎片

在第1章給出的簡化說明中, 一個雙鏈表即可滿足伙伴系統的所有需求. 在內核版本2.6.23之前, 的確是這樣. 但在內核2.6.24開發期間, 內核開發者對伙伴系統的爭論持續了相當長時間. 這是因為伙伴系統是內核最值得尊敬的一部分，對它的改動不會被大家輕易接受

內存碎片

伙伴系統的基本原理已經在第1章中討論過，其方案在最近幾年間確實工作得非常好。但在Linux內存管理方面，有一個長期存在的問題：在系統啟動并長期運行后，物理內存會產生很多碎片。該情形如下圖所示

pYYBAGJ_VpWAGY1tAAB071S-eh4125.jpg?source=d16d100b

假定內存由60頁組成，這顯然不是超級計算機，但用于示例卻足夠了。左側的地址空間中散布著空閑頁。盡管大約25%的物理內存仍然未分配，但最大的連續空閑區只有一頁. 這對用戶空間應用程序沒有問題：其內存是通過頁表映射的，無論空閑頁在物理內存中的分布如何，應用程序看到的內存似乎總是連續的。右圖給出的情形中，空閑頁和使用頁的數目與左圖相同，但所有空閑頁都位于一個連續區中。

但對內核來說，碎片是一個問題. 由于(大多數)物理內存一致映射到地址空間的內核部分, 那么在左圖的場景中, 無法映射比一頁更大的內存區. 盡管許多時候內核都分配的是比較小的內存, 但也有時候需要分配多于一頁的內存. 顯而易見, 在分配較大內存的情況下, 右圖中所有已分配頁和空閑頁都處于連續內存區的情形，是更為可取的.

很有趣的一點是, 在大部分內存仍然未分配時, 就也可能發生碎片問題. 考慮圖3-25的情形.

只分配了4頁，但可分配的最大連續區只有8頁，因為伙伴系統所能工作的分配范圍只能是2的冪次.

poYBAGJ_VpWAPWtAAABl3WrDIy4264.jpg?source=d16d100b

我提到內存碎片只涉及內核，這只是部分正確的。大多數現代CPU都提供了使用巨型頁的可能性，比普通頁大得多。這對內存使用密集的應用程序有好處。在使用更大的頁時，地址轉換后備緩沖器只需處理較少的項，降低了TLB緩存失效的可能性。但分配巨型頁需要連續的空閑物理內存！

很長時間以來，物理內存的碎片確實是Linux的弱點之一。盡管已經提出了許多方法，但沒有哪個方法能夠既滿足Linux需要處理的各種類型工作負荷提出的苛刻需求，同時又對其他事務影響不大。

依據可移動性組織頁

在內核2.6.24開發期間，防止碎片的方法最終加入內核。在我討論具體策略之前，有一點需要澄清。

文件系統也有碎片，該領域的碎片問題主要通過碎片合并工具解決。它們分析文件系統，重新排序已分配存儲塊，從而建立較大的連續存儲區. 理論上，該方法對物理內存也是可能的，但由于許多物理內存頁不能移動到任意位置，阻礙了該方法的實施。因此，內核的方法是反碎片(anti-fragmentation), 即試圖從最初開始盡可能防止碎片.

反碎片的工作原理如何?

為理解該方法，我們必須知道內核將已分配頁劃分為下面3種不同類型。

頁面類型	描述	舉例
不可移動頁	在內存中有固定位置, 不能移動到其他地方.	核心內核分配的大多數內存屬于該類別
可移動頁	可以隨意地移動. 屬于用戶空間應用程序的頁屬于該類別.	它們是通過頁表映射的如果它們復制到新位置，頁表項可以相應地更新，應用程序不會注意到任何事
可回收頁	不能直接移動, 但可以刪除, 其內容可以從某些源重新生成.	例如，映射自文件的數據屬于該類別 kswapd守護進程會根據可回收頁訪問的頻繁程度，周期性釋放此類內存. , 頁面回收本身就是一個復雜的過程. 內核會在可回收頁占據了太多內存時進行回收, 在內存短缺(即分配失敗)時也可以發起頁面回收.

頁的可移動性，依賴該頁屬于3種類別的哪一種. 內核使用的反碎片技術, 即基于將具有相同可移動性的頁分組的思想.

為什么這種方法有助于減少碎片?

由于頁無法移動, 導致在原本幾乎全空的內存區中無法進行連續分配. 根據頁的可移動性, 將其分配到不同的列表中, 即可防止這種情形. 例如, 不可移動的頁不能位于可移動內存區的中間, 否則就無法從該內存區分配較大的連續內存塊.

想一下, 上圖中大多數空閑頁都屬于可回收的類別, 而分配的頁則是不可移動的. 如果這些頁聚集到兩個不同的列表中, 如下圖所示. 在不可移動頁中仍然難以找到較大的連續空閑空間, 但對可回收的頁, 就容易多了.

poYBAGJ_VpWAR00LAABYdkUXgVU655.jpg?source=d16d100b

但要注意, 從最初開始, 內存并未劃分為可移動性不同的區. 這些是在運行時形成的. 內核的另一種方法確實將內存分區, 分別用于可移動頁和不可移動頁的分配, 我會下文討論其工作原理. 但這種劃分對這里描述的方法是不必要的

避免碎片數據結構

enum {
        MIGRATE_UNMOVABLE,
        MIGRATE_MOVABLE,
        MIGRATE_RECLAIMABLE,
        MIGRATE_PCPTYPES,       /* the number of types on the pcp lists */
        MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
#ifdef CONFIG_CMA
        /*
         * MIGRATE_CMA migration type is designed to mimic the way
         * ZONE_MOVABLE works.  Only movable pages can be allocated
         * from MIGRATE_CMA pageblocks and page allocator never
         * implicitly change migration type of MIGRATE_CMA pageblock.
         *
         * The way to use it is to change migratetype of a range of
         * pageblocks to MIGRATE_CMA which can be done by
         * __free_pageblock_cma() function.  What is important though
         * is that a range of pageblocks must be aligned to
         * MAX_ORDER_NR_PAGES should biggest page be bigger then
         * a single pageblock.
         */
        MIGRATE_CMA,
#endif
#ifdef CONFIG_MEMORY_ISOLATION
        MIGRATE_ISOLATE,        /* can't allocate from here */
#endif
        MIGRATE_TYPES
};

宏	類型
MIGRATE_UNMOVABLE	不可移動頁
MIGRATE_MOVABLE	可移動頁
MIGRATE_RECLAIMABLE	可回收頁
MIGRATE_PCPTYPES	是per_cpu_pageset, 即用來表示每CPU頁框高速緩存的數據結構中的鏈表的遷移類型數目
MIGRATE_HIGHATOMIC	在罕見的情況下，內核需要分配一個高階的頁面塊而不能休眠.如果向具有特定可移動性的列表請求分配內存失敗，這種緊急情況下可從MIGRATE_HIGHATOMIC中分配內存
MIGRATE_CMA	Linux內核最新的連續內存分配器(CMA), 用于避免預留大塊內存
MIGRATE_ISOLATE	是一個特殊的虛擬區域, 用于跨越NUMA結點移動物理內存頁. 在大型系統上, 它有益于將物理內存頁移動到接近于使用該頁最頻繁的CPU.
MIGRATE_TYPES	?

對于MIGRATE_CMA類型, 其中在我們使用ARM等嵌入式Linux系統的時候, 一個頭疼的問題是GPU, Camera, HDMI等都需要預留大量連續內存，這部分內存平時不用，但是一般的做法又必須先預留著. 目前, Marek Szyprowski和Michal Nazarewicz實現了一套全新的Contiguous Memory Allocator. 通過這套機制, 我們可以做到不預留內存，這些內存平時是可用的，只有當需要的時候才被分配給Camera，HDMI等設備. 內核為此提供了函數is_migrate_cma來檢測當前類型是否為MIGRATE_CMA, 該函數定義在include/linux/mmzone.h?v=4.7, line 69

/* In mm/page_alloc.c; keep in sync also with show_migration_types() there */
extern char * const migratetype_names[MIGRATE_TYPES];

#ifdef CONFIG_CMA
#  define is_migrate_cma(migratetype) unlikely((migratetype) == MIGRATE_CMA)
#else
#  define is_migrate_cma(migratetype) false
#endif

對伙伴系統數據結構的主要調整, 是將空閑列表分解為MIGRATE_TYPE個列表, 可以參見free_area的定義include/linux/mmzone.h?v=4.7, line 88

struct free_area
{
    struct list_head        free_list[MIGRATE_TYPES];
    unsigned long           nr_free;
};
nr_free統計了所有列表上空閑頁的數目，而每種遷移類型都對應于一個空閑列表
宏for_each_migratetype_order(order, type)可用于迭代指定遷移類型的所有分配階
#define for_each_migratetype_order(order, type) \
        for (order = 0; order < MAX_ORDER; order++) \
                for (type = 0; type < MIGRATE_TYPES; type++)

遷移備用列表fallbacks

如果內核無法滿足針對某一給定遷移類型的分配請求, 會怎么樣?

此前已經出現過一個類似的問題, 即特定的NUMA內存域無法滿足分配請求時. 我們需要從其他內存域中選擇一個代價最低的內存域完成內存的分配, 因此內核在內存的結點pg_data_t中提供了一個備用內存域列表zonelists.

內核在內存遷移的過程中處理這種情況下的做法是類似的. 提供了一個備用列表fallbacks, 規定了在指定列表中無法滿足分配請求時. 接下來應使用哪一種遷移類型, 定義在mm/page_alloc.c?v=4.7, line 1799

/*
 * This array describes the order lists are fallen back to when
 * the free lists for the desirable migrate type are depleted
 * 該數組描述了指定遷移類型的空閑列表耗盡時
 * 其他空閑列表在備用列表中的次序
 */
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
};

該數據結構大體上是自明的 : 每一行對應一個類型的備用搜索域的順序, 在內核想要分配不可移動頁MIGRATE_UNMOVABLE時, 如果對應鏈表為空, 則遍歷fallbacks[MIGRATE_UNMOVABLE], 首先后退到可回收頁鏈表MIGRATE_RECLAIMABLE, 接下來到可移動頁鏈表MIGRATE_MOVABLE, 最后到緊急分配鏈表MIGRATE_TYPES.

pageblock_order變量

全局變量和輔助函數盡管頁可移動性分組特性總是編譯到內核中，但只有在系統中有足夠內存可以分配到多個遷移類型對應的鏈表時，才是有意義的。由于每個遷移鏈表都應該有適當數量的內存，內核需要定義”適當”的概念. 這是通過兩個全局變量pageblock_order和pageblock_nr_pages提供的. 第一個表示內核認為是”大”的一個分配階, pageblock_nr_pages則表示該分配階對應的頁數。如果體系結構提供了巨型頁機制, 則pageblock_order通常定義為巨型頁對應的分配階. 定義在include/linux/pageblock-flags.h?v=4.7, line 44

#ifdef CONFIG_HUGETLB_PAGE

    #ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE

        /* Huge page sizes are variable */
        extern unsigned int pageblock_order;

    #else /* CONFIG_HUGETLB_PAGE_SIZE_VARIABLE */

    /* Huge pages are a constant size */
        #define pageblock_order         HUGETLB_PAGE_ORDER

    #endif /* CONFIG_HUGETLB_PAGE_SIZE_VARIABLE */

#else /* CONFIG_HUGETLB_PAGE */

    /* If huge pages are not used, group by MAX_ORDER_NR_PAGES */
    #define pageblock_order         (MAX_ORDER-1)

#endif /* CONFIG_HUGETLB_PAGE */

#define pageblock_nr_pages      (1UL << pageblock_order)

在IA-32體系結構上, 巨型頁長度是4MB, 因此每個巨型頁由1024個普通頁組成, 而HUGETLB_PAGE_ORDER則定義為10. 相比之下, IA-64體系結構允許設置可變的普通和巨型頁長度, 因此HUGETLB_PAGE_ORDER的值取決于內核配置.

如果體系結構不支持巨型頁, 則將其定義為第二高的分配階, 即MAX_ORDER - 1

/* If huge pages are not used, group by MAX_ORDER_NR_PAGES */
#define pageblock_order         (MAX_ORDER-1)

如果各遷移類型的鏈表中沒有一塊較大的連續內存, 那么頁面遷移不會提供任何好處, 因此在可用內存太少時內核會關閉該特性. 這是在build_all_zonelists函數中檢查的, 該函數用于初始化內存域列表. 如果沒有足夠的內存可用, 則全局變量page_group_by_mobility_disabled設置為0, 否則設置為1.

內核如何知道給定的分配內存屬于何種遷移類型?

我們將在以后講解, 有關各個內存分配的細節都通過分配掩碼指定.

內核提供了兩個標志，分別用于表示分配的內存是可移動的(__GFP_MOVABLE)或可回收的(__GFP_RECLAIMABLE).

gfpflags_to_migratetype函數

/* Convert GFP flags to their corresponding migrate type */
static inline int allocflags_to_migratetype(gfp_t gfp_flags)
{
    WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);

    if (unlikely(page_group_by_mobility_disabled))
        return MIGRATE_UNMOVABLE;

    /* Group based on mobility */
    return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
        ((gfp_flags & __GFP_RECLAIMABLE) != 0);
}

如果停用了頁面遷移特性, 則所有的頁都是不可移動的. 否則. 該函數的返回值可以直接用作free_area.free_list的數組索引.

pageblock_flags變量與其函數接口

最后要注意, 每個內存域都提供了一個特殊的字段, 可以跟蹤包含pageblock_nr_pages個頁的內存區的屬性. 即zone->pageblock_flags字段, 當前只有與頁可移動性相關的代碼使用, 參見include/linux/mmzone.h?v=4.7, line 367

struct zone
{
#ifndef CONFIG_SPARSEMEM
    /*
     * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
     * In SPARSEMEM, this map is stored in struct mem_section
     */
    unsigned long       *pageblock_flags;
#endif /* CONFIG_SPARSEMEM */
};

在初始化期間, 內核自動確保對內存域中的每個不同的遷移類型分組, 在pageblock_flags中都分配了足夠存儲NR_PAGEBLOCK_BITS個比特位的空間。當前，表示一個連續內存區的遷移類型需要3個比特位, 參見include/linux/pageblock-flags.h?v=4.7, line 28

/* Bit indices that affect a whole block of pages */
enum pageblock_bits {
    PB_migrate,
    PB_migrate_end = PB_migrate + 3 - 1,
            /* 3 bits required for migrate types */
    PB_migrate_skip,/* If set the block is skipped by compaction */

    /*
     * Assume the bits will always align on a word. If this assumption
     * changes then get/set pageblock needs updating.
     */
    NR_PAGEBLOCK_BITS
};

內核提供set_pageblock_migratetype負責設置以page為首的一個內存區的遷移類型, 該函數定義在mm/page_alloc.c?v=4.7, line 458, 如下所示

void set_pageblock_migratetype(struct page *page, int migratetype)
{
    if (unlikely(page_group_by_mobility_disabled &&
             migratetype < MIGRATE_PCPTYPES))
        migratetype = MIGRATE_UNMOVABLE;

    set_pageblock_flags_group(page, (unsigned long)migratetype,
                    PB_migrate, PB_migrate_end);
}

migratetype參數可以通過上文介紹的gfpflags_to_migratetype輔助函數構建. 請注意很重要的一點, 頁的遷移類型是預先分配好的, 對應的比特位總是可用, 與頁是否由伙伴系統管理無關. 在釋放內存時，頁必須返回到正確的遷移鏈表。這之所以可行，是因為能夠從get_pageblock_migratetype獲得所需的信息. 參見include/linux/mmzone.h?v=4.7, line 84

#define get_pageblock_migratetype(page)                                 \
        get_pfnblock_flags_mask(page, page_to_pfn(page),                \
                        PB_migrate_end, MIGRATETYPE_MASK)

最后請注意, 在各個遷移鏈表之間, 當前的頁面分配狀態可以從/proc/pagetypeinfo獲得.

初始化基于可移動性的分組

在內存子系統初始化期間, memmap_init_zone負責處理內存域的page實例. 該函數完成了一些不怎么有趣的標準初始化工作，但其中有一件是實質性的，即所有的頁最初都標記為可移動的. 參見mm/page_alloc.c?v=4.7, line 5224

/*
 * Initially all pages are reserved - free ones are freed
 * up by free_all_bootmem() once the early boot process is
 * done. Non-atomic initialization, single-pass.
 */
void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
        unsigned long start_pfn, enum memmap_context context)
{
    /*  ......  */

    for (pfn = start_pfn; pfn < end_pfn; pfn++) {
        /*  ......  */
not_early:
        if (!(pfn & (pageblock_nr_pages - 1))) {
            struct page *page = pfn_to_page(pfn);

            __init_single_page(page, pfn, zone, nid);
            set_pageblock_migratetype(page, MIGRATE_MOVABLE);
        } else {
            __init_single_pfn(pfn, zone, nid);
        }
    }
}

在分配內存時, 如果必須”盜取”不同于預定遷移類型的內存區, 內核在策略上傾向于”盜取”更大的內存區. 由于所有頁最初都是可移動的, 那么在內核分配不可移動的內存區時, 則必須”盜取”.

實際上, 在啟動期間分配可移動內存區的情況較少, 那么分配器有很高的幾率分配長度最大的內存區, 并將其從可移動列表轉換到不可移動列表. 由于分配的內存區長度是最大的, 因此不會向可移動內存中引入碎片.

總而言之, 這種做法避免了啟動期間內核分配的內存(經常在系統的整個運行時間都不釋放)散布到物理內存各處, 從而使其他類型的內存分配免受碎片的干擾，這也是頁可移動性分組框架的最重要的目標之一.

分配器API

分配內存的接口

就伙伴系統的接口而言, NUMA或UMA體系結構是沒有差別的, 二者的調用語法都是相同的.

所有函數的一個共同點是 : 只能分配2的整數冪個頁.

因此，接口中不像C標準庫的malloc函數或bootmem和memblock分配器那樣指定了所需內存大小作為參數. 相反, 必須指定的是分配階, 伙伴系統將在內存中分配2^0 rder頁. 內核中細粒度的分配只能借助于slab分配器(或者slub、slob分配器), 后者基于伙伴系統

pYYBAGJ_VpWAWDxzAAChiaRsETY297.jpg?source=d16d100b

在空閑內存無法滿足請求以至于分配失敗的情況下，所有上述函數都返回空指針(比如alloc_pages和alloc_page)或者0(比如get_zeroed_page、__get_free_pages和__get_free_page).

因此內核在各次分配之后都必須檢查返回的結果. 這種慣例與設計得很好的用戶層應用程序沒什么不同, 但在內核中忽略檢查會導致嚴重得多的故障

內核除了伙伴系統函數之外, 還提供了其他內存管理函數. 它們以伙伴系統為基礎, 但并不屬于伙伴分配器自身. 這些函數包括vmalloc和vmalloc_32, 使用頁表將不連續的內存映射到內核地址空間中, 使之看上去是連續的.

還有一組kmalloc類型的函數, 用于分配小于一整頁的內存區. 其實現.

釋放函數

有4個函數用于釋放不再使用的頁，與所述函數稍有不同

poYBAGJ_VpaARg6-AABNxgeiuoU777.jpg?source=d16d100b

分配掩碼(gfp_mask標志)

分配掩碼

前述所有函數中強制使用的mask參數，到底是什么語義?

我們知道Linux將內存劃分為內存域. 內核提供了所謂的內存域修飾符(zone modifier)(在掩碼的最低4個比特位定義), 來指定從哪個內存域分配所需的頁.

內核使用宏的方式定義了這些掩碼, 一個掩碼的定義被劃分為3個部分進行定義, 我們會逐步展開來講解, 參見include/linux/gfp.h?v=4.7, line 12~374, 共計26個掩碼信息, 因此后面__GFP_BITS_SHIFT = 26.

掩碼分類

Linux中這些掩碼標志gfp_mask分為3種類型 :

pYYBAGJ_VpaAFmoIAAAfp_1KpHY907.jpg?source=d16d100b

內核中掩碼的定義

內核中的定義方式

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7

/*  line 12 ~ line 44  第一部分
 *  定義可掩碼所在位的信息, 每個掩碼對應一位為1
 *  定義形式為  #define  ___GFP_XXX      0x01u
 */
/* Plain integer GFP bitmasks. Do not use this directly. */
#define ___GFP_DMA              0x01u
#define ___GFP_HIGHMEM          0x02u
#define ___GFP_DMA32            0x04u
#define ___GFP_MOVABLE          0x08u
/*  ......  */

/*  line 46 ~ line 192  第二部分
 *  定義掩碼和MASK信息, 第二部分的某些宏可能是第一部分一個或者幾個的組合
 *  定義形式為  #define  __GFP_XXX        ((__force gfp_t)___GFP_XXX)
 */
#define __GFP_DMA       ((__force gfp_t)___GFP_DMA)
#define __GFP_HIGHMEM   ((__force gfp_t)___GFP_HIGHMEM)
#define __GFP_DMA32     ((__force gfp_t)___GFP_DMA32)
#define __GFP_MOVABLE   ((__force gfp_t)___GFP_MOVABLE)  /* ZONE_MOVABLE allowed */
#define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)

/*  line 194 ~ line 260  第三部分
 *  定義掩碼
 *  定義形式為  #define  GFP_XXX      __GFP_XXX
 */
#define GFP_DMA         __GFP_DMA
#define GFP_DMA32       __GFP_DMA32

其中GFP縮寫的意思為獲取空閑頁(get free page), __GFP_MOVABLE不表示物理內存域, 但通知內核應在特殊的虛擬內存域ZONE_MOVABLE進行相應的分配.

定義掩碼位

我們首先來看第一部分, 內核源代碼中定義在include/linux/gfp.h?v=4.7, line 18 ~ line 44, 共計26個掩碼信息.

/* Plain integer GFP bitmasks. Do not use this directly. */
//  區域修飾符
#define ___GFP_DMA              0x01u
#define ___GFP_HIGHMEM          0x02u
#define ___GFP_DMA32            0x04u

//  行為修飾符
#define ___GFP_MOVABLE          0x08u       /* 頁是可移動的 */
#define ___GFP_RECLAIMABLE      0x10u       /* 頁是可回收的 */
#define ___GFP_HIGH             0x20u       /* 應該訪問緊急分配池？ */
#define ___GFP_IO               0x40u       /* 可以啟動物理IO？ */
#define ___GFP_FS               0x80u       /* 可以調用底層文件系統？ */
#define ___GFP_COLD             0x100u     /* 需要非緩存的冷頁 */
#define ___GFP_NOWARN           0x200u     /* 禁止分配失敗警告 */
#define ___GFP_REPEAT           0x400u     /* 重試分配，可能失敗 */
#define ___GFP_NOFAIL           0x800u     /* 一直重試，不會失敗 */
#define ___GFP_NORETRY          0x1000u   /* 不重試，可能失敗 */
#define ___GFP_MEMALLOC         0x2000u     /* 使用緊急分配鏈表 */
#define ___GFP_COMP             0x4000u   /* 增加復合頁元數據 */
#define ___GFP_ZERO             0x8000u   /* 成功則返回填充字節0的頁 */
//  類型修飾符
#define ___GFP_NOMEMALLOC       0x10000u     /* 不使用緊急分配鏈表 */
#define ___GFP_HARDWALL         0x20000u     /* 只允許在進程允許運行的CPU所關聯的結點分配內存 */
#define ___GFP_THISNODE         0x40000u     /* 沒有備用結點，沒有策略 */
#define ___GFP_ATOMIC           0x80000u    /* 用于原子分配，在任何情況下都不能中斷  */
#define ___GFP_ACCOUNT          0x100000u
#define ___GFP_NOTRACK          0x200000u
#define ___GFP_DIRECT_RECLAIM   0x400000u
#define ___GFP_OTHER_NODE       0x800000u
#define ___GFP_WRITE            0x1000000u
#define ___GFP_KSWAPD_RECLAIM   0x2000000u

定義掩碼

然后第二部分, 相對而言每一個宏又被重新定義如下, 參見include/linux/gfp.h?v=4.7, line 46 ~ line 192

/*
* Physical address zone modifiers (see linux/mmzone.h - low four bits)
*
* Do not put any conditional on these. If necessary modify the definitions
* without the underscores and use them consistently. The definitions here may
* be used in bit comparisons.
* 定義區描述符
*/
#define __GFP_DMA       ((__force gfp_t)___GFP_DMA)
#define __GFP_HIGHMEM   ((__force gfp_t)___GFP_HIGHMEM)
#define __GFP_DMA32     ((__force gfp_t)___GFP_DMA32)
#define __GFP_MOVABLE   ((__force gfp_t)___GFP_MOVABLE)  /* ZONE_MOVABLE allowed */
#define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)

/*
* Page mobility and placement hints
*
* These flags provide hints about how mobile the page is. Pages with similar
* mobility are placed within the same pageblocks to minimise problems due
* to external fragmentation.
*
* __GFP_MOVABLE (also a zone modifier) indicates that the page can be
*   moved by page migration during memory compaction or can be reclaimed.
*
* __GFP_RECLAIMABLE is used for slab allocations that specify
*   SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
*
* __GFP_WRITE indicates the caller intends to dirty the page. Where possible,
*   these pages will be spread between local zones to avoid all the dirty
*   pages being in one zone (fair zone allocation policy).
*
* __GFP_HARDWALL enforces the cpuset memory allocation policy.
*
* __GFP_THISNODE forces the allocation to be satisified from the requested
*   node with no fallbacks or placement policy enforcements.
*
* __GFP_ACCOUNT causes the allocation to be accounted to kmemcg (only relevant
*   to kmem allocations).
*/
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE)
#define __GFP_WRITE     ((__force gfp_t)___GFP_WRITE)
#define __GFP_HARDWALL   ((__force gfp_t)___GFP_HARDWALL)
#define __GFP_THISNODE  ((__force gfp_t)___GFP_THISNODE)
#define __GFP_ACCOUNT   ((__force gfp_t)___GFP_ACCOUNT)

/*
* Watermark modifiers -- controls access to emergency reserves
*
* __GFP_HIGH indicates that the caller is high-priority and that granting
*   the request is necessary before the system can make forward progress.
*   For example, creating an IO context to clean pages.
*
* __GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
*   high priority. Users are typically interrupt handlers. This may be
*   used in conjunction with __GFP_HIGH
 *
 * __GFP_MEMALLOC allows access to all memory. This should only be used when
 *   the caller guarantees the allocation will allow more memory to be freed
 *   very shortly e.g. process exiting or swapping. Users either should
 *   be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
 *
 * __GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
 *   This takes precedence over the __GFP_MEMALLOC flag if both are set.
 */
#define __GFP_ATOMIC    ((__force gfp_t)___GFP_ATOMIC)
#define __GFP_HIGH      ((__force gfp_t)___GFP_HIGH)
#define __GFP_MEMALLOC  ((__force gfp_t)___GFP_MEMALLOC)
#define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC)

/*
 * Reclaim modifiers
 *
 * __GFP_IO can start physical IO.
 *
 * __GFP_FS can call down to the low-level FS. Clearing the flag avoids the
 *   allocator recursing into the filesystem which might already be holding
 *   locks.
 *
 * __GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
 *   This flag can be cleared to avoid unnecessary delays when a fallback
 *   option is available.
 *
 * __GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
 *   the low watermark is reached and have it reclaim pages until the high
 *   watermark is reached. A caller may wish to clear this flag when fallback
 *   options are available and the reclaim is likely to disrupt the system. The
 *   canonical example is THP allocation where a fallback is cheap but
 *   reclaim/compaction may cause indirect stalls.
 *
 * __GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
 *
 * __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
 *   _might_ fail.  This depends upon the particular VM implementation.
 *
 * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
 *   cannot handle allocation failures. New users should be evaluated carefully
 *   (and the flag should be used only when there is no reasonable failure
 *   policy) but it is definitely preferable to use the flag rather than
 *   opencode endless loop around allocator.
 *
 * __GFP_NORETRY: The VM implementation must not retry indefinitely and will
 *   return NULL when direct reclaim and memory compaction have failed to allow
 *   the allocation to succeed.  The OOM killer is not called with the current
 *   implementation.
 */
#define __GFP_IO        ((__force gfp_t)___GFP_IO)
#define __GFP_FS        ((__force gfp_t)___GFP_FS)
#define __GFP_DIRECT_RECLAIM    ((__force gfp_t)___GFP_DIRECT_RECLAIM) /* Caller can reclaim */
#define __GFP_KSWAPD_RECLAIM    ((__force gfp_t)___GFP_KSWAPD_RECLAIM) /* kswapd can wake */
#define __GFP_RECLAIM ((__force gfp_t)(___GFP_DIRECT_RECLAIM|___GFP_KSWAPD_RECLAIM))
#define __GFP_REPEAT    ((__force gfp_t)___GFP_REPEAT)
#define __GFP_NOFAIL    ((__force gfp_t)___GFP_NOFAIL)
#define __GFP_NORETRY   ((__force gfp_t)___GFP_NORETRY)

/*
 * Action modifiers
 *
 * __GFP_COLD indicates that the caller does not expect to be used in the near
 *   future. Where possible, a cache-cold page will be returned.
 *
 * __GFP_NOWARN suppresses allocation failure reports.
 *
 * __GFP_COMP address compound page metadata.
 *
 * __GFP_ZERO returns a zeroed page on success.
 *
 * __GFP_NOTRACK avoids tracking with kmemcheck.
 *
 * __GFP_NOTRACK_FALSE_POSITIVE is an alias of __GFP_NOTRACK. It's a means of
 *   distinguishing in the source between false positives and allocations that
 *   cannot be supported (e.g. page tables).
 *
 * __GFP_OTHER_NODE is for allocations that are on a remote node but that
 *   should not be accounted for as a remote allocation in vmstat. A
 *   typical user would be khugepaged collapsing a huge page on a remote
 *   node.
 */
#define __GFP_COLD      ((__force gfp_t)___GFP_COLD)
#define __GFP_NOWARN    ((__force gfp_t)___GFP_NOWARN)
#define __GFP_COMP      ((__force gfp_t)___GFP_COMP)
#define __GFP_ZERO      ((__force gfp_t)___GFP_ZERO)
#define __GFP_NOTRACK   ((__force gfp_t)___GFP_NOTRACK)
#define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
#define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE)

/* Room for N __GFP_FOO bits */
#define __GFP_BITS_SHIFT 26
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))

給出的常數，其中一些很少使用，因此我不會討論。其中最重要的一些常數語義如下所示

其中在開始的位置定義了對應的區修飾符,

poYBAGJ_VpaAbC8OAAAZVCbWCew045.jpg?source=d16d100b

其次還定義了我們程序和函數中所需要的掩碼MASK的信息, 由于其中__GFP_DMA, __GFP_DMA32, __GFP_HIGHMEM, __GFP_MOVABLE是在內存中分別有對應的內存域信息, 因此我們定義了內存域的掩碼GFP_ZONEMASK, 參見include/linux/gfp.h?v=4.7, line 57

#define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)

接著內核定義了行為修飾符

/* __GFP_WAIT表示分配內存的請求可以中斷。也就是說，調度器在該請求期間可隨意選擇另一個過程執行，或者該請求可以被另一個更重要的事件中斷. 分配器還可以在返回內存之前, 在隊列上等待一個事件(相關進程會進入睡眠狀態).

雖然名字相似，但__GFP_HIGH與__GFP_HIGHMEM毫無關系，請不要弄混這兩者\

行為修飾符	描述
__GFP_RECLAIMABLE __GFP_MOVABLE	是頁遷移機制所需的標志. 顧名思義，它們分別將分配的內存標記為可回收的或可移動的。這影響從空閑列表的哪個子表獲取內存
__GFP_WRITE	?
__GFP_HARDWALL	只在NUMA系統上有意義. 它限制只在分配到當前進程的各個CPU所關聯的結點分配內存。如果進程允許在所有CPU上運行（默認情況），該標志是無意義的。只有進程可以運行的CPU受限時，該標志才有效果
__GFP_THISNODE	也只在NUMA系統上有意義。如果設置該比特位，則內存分配失敗的情況下不允許使用其他結點作為備用，需要保證在當前結點或者明確指定的結點上成功分配內存
__GFP_ACCOUNT	?
__GFP_ATOMIC	?
__GFP_HIGH	如果請求非常重要, 則設置__GFP_HIGH，即內核急切地需要內存時。在分配內存失敗可能給內核帶來嚴重后果時(比如威脅到系統穩定性或系統崩潰), 總是會使用該標志
__GFP_MEMALLOC	?
__GFP_NOMEMALLOC	?
__GFP_IO	說明在查找空閑內存期間內核可以進行I/O操作. 實際上, 這意味著如果內核在內存分配期間換出頁, 那么僅當設置該標志時, 才能將選擇的頁寫入硬盤
__GFP_FS	允許內核執行VFS操作. 在與VFS層有聯系的內核子系統中必須禁用, 因為這可能引起循環遞歸調用.
__GFP_DIRECT_RECLAIM	?
__GFP_KSWAPD_RECLAIM	?
__GFP_RECLAIM	?
__GFP_REPEAT	在分配失敗后自動重試，但在嘗試若干次之后會停止
__GFP_NOFAIL	在分配失敗后一直重試，直至成功
__GFP_NORETRY	在分配失敗后不重試，因此可能分配失敗
__GFP_COLD	如果需要分配不在CPU高速緩存中的“冷”頁時，則設置__GFP_COLD
__GFP_NOWARN	在分配失敗時禁止內核故障警告。在極少數場合該標志有用
__GFP_COMP	添加混合頁元素, 在hugetlb的代碼內部使用
__GFP_ZERO	在分配成功時，將返回填充字節0的頁
__GFP_NOTRACK	?
__GFP_NOTRACK_FALSE_POSITIVE __GFP_NOTRACK	?
__GFP_OTHER_NODE	?

那自然還有__GFP_BITS_SHIFT來表示我們所有的掩碼位, 由于我們共計26個掩碼位

/* Room for N __GFP_FOO bits */
#define __GFP_BITS_SHIFT 26
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))

可以同時指定這些分配標志, 例如

ptr = kmalloc(size, __GFP_IO | __GFP_FS);

說明頁分配器(最終會調用alloc_page)在分配時可以執行I/O, 在必要時還可以執行文件系統操作. 這就讓內核有很大的自由度, 以便它盡可能找到空閑的內存來滿足分配請求. 大多數分配器都會執行這些修飾符, 但一般不是這樣直接指定, 而是將這些行為描述符標志進行分組, 即類型標志

掩碼分組

最后來看第三部分, 由于這些標志幾乎總是組合使用，內核作了一些分組，包含了用于各種標準情形的適當的標志. 稱之為類型標志,

類型標志指定所需的行為和區描述符以安城特殊類型的處理, 正因為這一點, 內核總是趨于使用正確的類型標志, 而不是一味地指定它可能用到的多種描述符. 這么做既簡單又不容易出錯誤.如果有可能的話, 在內存管理子系統之外, 總是把下列分組之一用于內存分配. 在內核源代碼中, 雙下劃線通常用于內部數據和定義. 而這些預定義的分組名沒有雙下劃線前綴, 點從側面驗證了上述說法.

#define GFP_ATOMIC      (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
#define GFP_KERNEL      (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
#define GFP_KERNEL_ACCOUNT (GFP_KERNEL | __GFP_ACCOUNT)
#define GFP_NOWAIT      (__GFP_KSWAPD_RECLAIM)
#define GFP_NOIO        (__GFP_RECLAIM)
#define GFP_NOFS        (__GFP_RECLAIM | __GFP_IO)
#define GFP_TEMPORARY   (__GFP_RECLAIM | __GFP_IO | __GFP_FS | \
                         __GFP_RECLAIMABLE)
#define GFP_USER        (__GFP_RECLAIM | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
#define GFP_DMA         __GFP_DMA
#define GFP_DMA32       __GFP_DMA32
#define GFP_HIGHUSER    (GFP_USER | __GFP_HIGHMEM)
#define GFP_HIGHUSER_MOVABLE    (GFP_HIGHUSER | __GFP_MOVABLE)
#define GFP_TRANSHUGE   ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
                         __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN) & \
                         ~__GFP_RECLAIM)

/* Convert GFP flags to their corresponding migrate type */
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
#define GFP_MOVABLE_SHIFT 3

掩碼組	描述
GFP_ATOMIC	用于原子分配，在任何情況下都不能中斷, 可能使用緊急分配鏈表中的內存, 這個標志用在中斷處理程序, 下半部, 持有自旋鎖以及其他不能睡眠的地方
GFP_KERNEL	這是一種常規的分配方式, 可能會阻塞. 這個標志在睡眠安全時用在進程的長下文代碼中. 為了獲取調用者所需的內存, 內核會盡力而為. 這個標志應該是首選標志
GFP_KERNEL_ACCOUNT	?
GFP_NOWAIT	與GFP_ATOMIC類似, 不同之處在于, 調用不會退給緊急內存池, 這就增加了內存分配失敗的可能性
GFP_NOIO	這種分配可以阻塞, 但不會啟動磁盤I/O, 這個標志在不能引發更多的磁盤I/O時阻塞I/O代碼, 這可能導致令人不愉快的遞歸
GFP_NOFS	這種分配在必要時可以阻塞, 但是也可能啟動磁盤, 但是不會啟動文件系統操作, 這個標志在你不鞥在啟動另一個文件系統操作時, 用在文件系統部分的代碼中 GFP_TEMPORARY
GFP_TEMPORARY	?
GFP_USER	這是一種常規的分配方式, 可能會阻塞. 這個標志用于為用戶空間進程分配內存時使用
GFP_DMA	?
GFP_DMA32	用于分配適用于DMA的內存, 當前是__GFP_DMA的同義詞, GFP_DMA32也是__GFP_GMA32的同義詞
GFP_HIGHUSER	是GFP_USER的一個擴展, 也用于用戶空間. 它允許分配無法直接映射的高端內存. 使用高端內存頁是沒有壞處的，因為用戶過程的地址空間總是通過非線性頁表組織的
GFP_HIGHUSER_MOVABLE	用途類似于GFP_HIGHUSER，但分配將從虛擬內存域ZONE_MOVABLE進行
GFP_TRANSHUGE	?

其中GFP_NOIO和GFP_NOFS, 分別明確禁止I/O操作和訪問VFS層, 但同時設置了__GFP_RECLAIM，因此可以被回收

而GFP_KERNEL和GFP_USER. 分別是內核和用戶分配的默認設置。二者的失敗不會立即威脅系統穩定性, GFP_KERNEL絕對是內核源代碼中最常使用的標志 |

最后內核設置了碎片管理的可移動依據組織頁的MASK信息GFP_MOVABLE_MASK,

/* Convert GFP flags to their corresponding migrate type */
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
#define GFP_MOVABLE_SHIFT 3

在你編寫的絕大多數代碼中, 用么用到的是GFP_KERNEL, 要么是GFP_ATOMIC, 當然各個類型標志也均有其應用場景

pYYBAGJ_VpaAWlFsAAAkt6s6m0M815.jpg?source=d16d100b

總結

我們從注釋中找到這樣的信息, 可以作為參考

bit       result
=================
0x0    => NORMAL
0x1    => DMA or NORMAL
0x2    => HIGHMEM or NORMAL
0x3    => BAD (DMA+HIGHMEM)
0x4    => DMA32 or DMA or NORMAL
0x5    => BAD (DMA+DMA32)
0x6    => BAD (HIGHMEM+DMA32)
0x7    => BAD (HIGHMEM+DMA32+DMA)
0x8    => NORMAL (MOVABLE+0)
0x9    => DMA or NORMAL (MOVABLE+DMA)
0xa    => MOVABLE (Movable is valid only if HIGHMEM is set too)
0xb    => BAD (MOVABLE+HIGHMEM+DMA)
0xc    => DMA32 (MOVABLE+DMA32)
0xd    => BAD (MOVABLE+DMA32+DMA)
0xe    => BAD (MOVABLE+DMA32+HIGHMEM)
0xf    => BAD (MOVABLE+DMA32+HIGHMEM+DMA)

GFP_ZONES_SHIFT must be <= 2 on 32 bit platforms.

很有趣的一點是，沒有__GFP_NORMAL常數，而內存分配的主要負擔卻落到ZONE_NORMAL內存域

內核考慮到這一點, 提供了一個函數gfp_zone來計算與給定分配標志兼容的最高內存域. 那么內存分配可以從該內存域或更低的內存域進行, 該函數定義在include/linux/gfp.h?v=4.7, line 394

#if defined(CONFIG_ZONE_DEVICE) && (MAX_NR_ZONES-1) <= 4
/* ZONE_DEVICE is not a valid GFP zone specifier */
#define GFP_ZONES_SHIFT 2
#else
#define GFP_ZONES_SHIFT ZONES_SHIFT
#endif

#if 16 * GFP_ZONES_SHIFT > BITS_PER_LONG
#error GFP_ZONES_SHIFT too large to create GFP_ZONE_TABLE integer
#endif

由于內存域修飾符的解釋方式不是那么直觀, 表3-7給出了該函數結果的一個例子, 其中DMA和DMA32內存域相同. 假定在下文中沒有設置__GFP_MOVABLE修飾符.

poYBAGJ_VpaAOvNAAAAYVnYx0bE415.jpg?source=d16d100b

如果__GFP_DMA和__GFP_HIGHMEM都沒有設置, 則首先掃描ZONE_NORMAL, 后面是ZONE_DMA

如果設置了__GFP_HIGHMEM沒有設置__GFP_DMA，則結果是從ZONE_HIGHMEM開始掃描所有3個內存域。

如果設置了__GFP_DMA，那么__GFP_HIGHMEM設置與否沒有關系. 只有ZONE_DMA用于3種情形. 這是合理的, 因為同時使用__GFP_HIGHMEM和__GFP_DMA沒有意義. 高端內存從來都不適用于DMA

設置__GFP_MOVABLE不會影響內核的決策，除非它與__GFP_HIGHMEM同時指定. 在這種情況下, 會使用特殊的虛擬內存域ZONE_MOVABLE滿足內存分配請求. 對前文描述的內核的反碎片策略而言, 這種行為是必要的.

除了內存域修飾符之外, 掩碼中還可以設置一些標志.

下圖中給出了掩碼的布局，以及與各個比特位置關聯的常數. __GFP_DMA32出現了幾次，因為它可能位于不同的地方.

pYYBAGJ_VpaACDbaAADpI6GV5Ok129.jpg?source=d16d100b

與內存域修飾符相反, 這些額外的標志并不限制從哪個物理內存段分配內存, 但確實可以改變分配器的行為. 例如, 它們可以修改查找空閑內存時的積極程度.

4.3 分配頁

4.3.1 內存分配統一到alloc_pages接口

通過使用標志、內存域修飾符和各個分配函數，內核提供了一種非常靈活的內存分配體系.盡管如此, 所有接口函數都可以追溯到一個簡單的基本函數(alloc_pages_node)

分配單頁的函數alloc_page和__get_free_page, 還有__get_dma_pages是借助于宏定義的.

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L483
#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L500
#define __get_free_page(gfp_mask) \
    __get_free_pages((gfp_mask), 0)`

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L503
#define __get_dma_pages(gfp_mask, order) \
    __get_free_pages((gfp_mask) | GFP_DMA, (order))

get_zeroed_page的實現也沒什么困難, 對__get_free_pages使用__GFP_ZERO標志，即可分配填充字節0的頁. 再返回與頁關聯的內存區地址即可.

//  http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.7#L3900
unsigned long get_zeroed_page(gfp_t gfp_mask)
{
        return __get_free_pages(gfp_mask | __GFP_ZERO, 0);
}
EXPORT_SYMBOL(get_zeroed_page);

__get_free_pages調用alloc_pages完成內存分配, 而alloc_pages又借助于alloc_pages_node

__get_free_pages函數的定義在mm/page_alloc.c?v=4.7, line 3883

//  http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.7#L3883
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
{
    struct page *page;

    /*
     * __get_free_pages() returns a 32-bit address, which cannot represent
     * a highmem page
     */
    VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);

    page = alloc_pages(gfp_mask, order);
    if (!page)
        return 0;
    return (unsigned long) page_address(page);
}
EXPORT_SYMBOL(__get_free_pages);

在這種情況下，使用了一個普通函數而不是宏，因為alloc_pages返回的page實例需要使用輔助

函數page_address轉換為內存地址. 在這里，只要知道該函數可根據page實例計算相關頁的線性內存地址即可. 對高端內存頁這是有問題的

這樣, 就完成了所有分配內存的API函數到公共的基礎函數alloc_pages的統一

poYBAGJ_VpaAZnnaAAB2G7p_Xsw820.jpg?source=d16d100b

所有體系結構都必須實現的標準函數clear_page, 可幫助alloc_pages對頁填充字節0, 實現如下表所示

pYYBAGJ_VpaAEb92AAARDK7fkSE224.jpg?source=d16d100b

alloc_pages函數分配頁

既然所有的內存分配API函數都可以追溯掉alloc_page函數, 從某種意義上說，該函數是伙伴系統主要實現的”發射臺”.

alloc_pages函數的定義是依賴于NUMA或者UMA架構的, 定義如下

#ifdef CONFIG_NUMA

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L465
static inline struct page *
alloc_pages(gfp_t gfp_mask, unsigned int order)
{
        return alloc_pages_current(gfp_mask, order);
}

#else

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L476
#define alloc_pages(gfp_mask, order) \
                alloc_pages_node(numa_node_id(), gfp_mask, order)
#endif

UMA結構下的alloc_pages是通過alloc_pages_node函數實現的, 下面我們看看alloc_pages_node函數的定義, 在include/linux/gfp.h?v=4.7, line 448

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L448
/*
 * Allocate pages, preferring the node given as nid. When nid == NUMA_NO_NODE,
 * prefer the current CPU's closest node. Otherwise node must be valid and
 * online.
 */
static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
                        unsigned int order)
{
    if (nid == NUMA_NO_NODE)
        nid = numa_mem_id();

    return __alloc_pages_node(nid, gfp_mask, order);
}

內核假定傳遞給改alloc_pages_node函數的結點nid是被激活, 即online的.但是為了安全它還是檢查并警告內存結點不存在的情況. 接下來的工作委托給__alloc_pages, 只需傳遞一組適當的參數, 其中包括節點nid的備用內存域列表zonelist.

現在__alloc_pages函數沒什么特別的, 它直接將自己的所有信息傳遞給__alloc_pages_nodemask來完成內存的分配

//  http://lxr.free-electrons.com/source/include/linux/gfp.h?v=4.7#L428
static inline struct page *
__alloc_pages(gfp_t gfp_mask, unsigned int order,
        struct zonelist *zonelist)
{
    return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
}

伙伴系統的心臟__alloc_pages_nodemask

內核源代碼將__alloc_pages稱之為”伙伴系統的心臟”(`the ‘heart’ of the zoned buddy allocator“), 因為它處理的是實質性的內存分配.

由于”心臟”的重要性, 我將在下文詳細介紹該函數.

__alloc_pages函數定義在include/linux/gfp.h?v=4.7#L428

//  http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.7#L3779
/*
 * This is the 'heart' of the zoned buddy allocator.
 */
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
            struct zonelist *zonelist, nodemask_t *nodemask)
{
    struct page *page;
    unsigned int cpuset_mems_cookie;
    unsigned int alloc_flags = ALLOC_WMARK_LOW|ALLOC_FAIR;
    gfp_t alloc_mask = gfp_mask; /* The gfp_t that was actually used for allocation */
    struct alloc_context ac = {
        .high_zoneidx = gfp_zone(gfp_mask),
        .zonelist = zonelist,
        .nodemask = nodemask,
        .migratetype = gfpflags_to_migratetype(gfp_mask),
    };

    if (cpusets_enabled()) {
        alloc_mask |= __GFP_HARDWALL;
        alloc_flags |= ALLOC_CPUSET;
        if (!ac.nodemask)
            ac.nodemask = &cpuset_current_mems_allowed;
    }

    gfp_mask &= gfp_allowed_mask;

    lockdep_trace_alloc(gfp_mask);

    might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);

    if (should_fail_alloc_page(gfp_mask, order))
        return NULL;

    /*
     * Check the zones suitable for the gfp_mask contain at least one
     * valid zone. It's possible to have an empty zonelist as a result
     * of __GFP_THISNODE and a memoryless node
     */
    if (unlikely(!zonelist->_zonerefs->zone))
        return NULL;

    if (IS_ENABLED(CONFIG_CMA) && ac.migratetype == MIGRATE_MOVABLE)
        alloc_flags |= ALLOC_CMA;

retry_cpuset:
    cpuset_mems_cookie = read_mems_allowed_begin();

    /* Dirty zone balancing only done in the fast path */
    ac.spread_dirty_pages = (gfp_mask & __GFP_WRITE);

    /*
     * The preferred zone is used for statistics but crucially it is
     * also used as the starting point for the zonelist iterator. It
     * may get reset for allocations that ignore memory policies.
     */
    ac.preferred_zoneref = first_zones_zonelist(ac.zonelist,
                    ac.high_zoneidx, ac.nodemask);
    if (!ac.preferred_zoneref) {
        page = NULL;
        goto no_zone;
    }

    /* First allocation attempt */
    page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
    if (likely(page))
        goto out;

    /*
     * Runtime PM, block IO and its error handling path can deadlock
     * because I/O on the device might not complete.
     */
    alloc_mask = memalloc_noio_flags(gfp_mask);
    ac.spread_dirty_pages = false;

    /*
     * Restore the original nodemask if it was potentially replaced with
     * &cpuset_current_mems_allowed to optimize the fast-path attempt.
     */
    if (cpusets_enabled())
        ac.nodemask = nodemask;
    page = __alloc_pages_slowpath(alloc_mask, order, &ac);

no_zone:
    /*
     * When updating a task's mems_allowed, it is possible to race with
     * parallel threads in such a way that an allocation can fail while
     * the mask is being updated. If a page allocation is about to fail,
     * check if the cpuset changed during allocation and if so, retry.
     */
    if (unlikely(!page && read_mems_allowed_retry(cpuset_mems_cookie))) {
        alloc_mask = gfp_mask;
        goto retry_cpuset;
    }

out:
    if (kmemcheck_enabled && page)
        kmemcheck_pagealloc_alloc(page, order, gfp_mask);

    trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);

    return page;
}
EXPORT_SYMBOL(__alloc_pages_nodemask);

__free_pages

類似地，內存釋放函數也可以歸約到一個主要的函數(__free_pages), 只是用不同的參數調用而已

前面我們講過內核釋放的兩個主要函數有__free_page和free_page,

void free_pages(unsigned long addr, unsigned int order)
{
    if (addr != 0) {
        VM_BUG_ON(!virt_addr_valid((void *)addr));
        __free_pages(virt_to_page((void *)addr), order);
    }
}

free_pages和__free_pages之間的關系通過函數而不是宏建立, 因為首先必須將虛擬地址轉換為指向struct page的指針

virt_to_page將虛擬內存地址轉換為指向page實例的指針. 基本上, 這是講解內存分配函數時介紹的page_address輔助函數的逆過程.

下圖以圖形化方式綜述了各個內存釋放函數之間的關系

poYBAGJ_VpeALCIfAABL4DQiziI363.jpg?source=d16d100b

審核編輯：湯梓紅

閱讀全文

Linux(206513) Linux(206513)
內存管理(14042) 內存管理(14042)
LINUX內核(21376) LINUX內核(21376)

深度分析Linux內存使用方法

一提到內存管理，我們頭腦中閃出的兩個概念，就是虛擬內存，與物理內存。這兩個概念主要來自于linux內核的支持。

2018-08-20 09:00:17

7045

Linux kernel內存管理模塊結構分析

基于上面章節的需求，Linux kernel從虛擬內存（VM）、DMA mapping以及DMA buffer sharing三個角度，對內存進行管理.

2020-09-19 11:55:15

1437

Linux的內存管理是什么，Linux的內存管理詳解

Linux的內存管理 Linux的內存管理是一個非常復雜的過程，主要分成兩個大的部分：內核的內存管理和進程虛擬內存。內核的內存管理是Linux內存管理的核心，所以我們先對內核的內存管理進行簡介

2022-05-11 17:54:17

5183

Linux內存管理之頁面回收

請求調頁機制，只要用戶態進程繼續執行，他們就能獲得頁框，然而，請求調頁沒有辦法強制進程釋放不再使用的頁框。因此，遲早所有空閑內存將被分配給進程和高速緩存，Linux內核的頁面回收算法（PFRA）采取從用戶進程和內核高速緩存“竊取”頁框的辦法不從伙伴系統的空閑塊列表。

2022-05-19 14:09:26

858

深度解析Linux的內存管理體系

Linux內存管理的整體模式是虛擬內存管理(分頁內存管理)，并在此基礎上建立了一個龐大的內存管理體系。我們先來看一下總體結構圖。

2022-08-06 16:55:59

1369

走進Linux內存系統探尋內存管理的機制和奧秘

Linux 內存是后臺開發人員，需要深入了解的計算機資源。合理的使用內存，有助于提升機器的性能和穩定性。本文主要介紹Linux 內存組織結構和頁面布局，內存碎片產生原因和優化算法，Linux 內核幾種內存管理的方法，內存使用場景以及內存使用的那些坑。

2023-01-05 09:47:43

1338

關于Linux內存管理的詳細介紹

Linux內存管理是指對系統內存的分配、釋放、映射、管理、交換、壓縮等一系列操作的管理。在Linux中，內存被劃分為多個區域，每個區域有不同的作用，包括內核空間、用戶空間、緩存、交換分區等。Linux內存管理的目標是最大限度地利用可用內存，同時保證系統的穩定和可靠性。

2023-03-06 09:28:45

844

一文詳解Linux虛擬內存技術

　　以存儲單元為單位來管理顯然不現實，因此Linux把虛存空間分成若干個大小相等的存儲分區，Linux把這樣的分區叫做頁。為了換入、換出的方便，物理內存也就按頁的大小分成若干個塊。由于物理內存中的塊空間是用來容納虛存頁的容器，所以物理內存中的塊叫做頁框。頁與頁框是Linux實現虛擬內存技術的基礎。

2023-07-17 17:29:45

382

Linux內存相關知識科普

，Linux 內核幾種內存管理的方法，內存使用場景以及內存使用的那些坑。**從內存的原理和結構，到內存的算法優化，再到使用場景，去探尋內存管理的機制和奧秘。

2023-07-25 14:43:45

490

Linux內核的物理內存組織結構詳解

Linux中內存管理子系統使用節點（node）、區域（zone）和頁（page）三級結構描述物理內存。

2023-08-21 15:35:24

222

Linux內核的內存管理詳解

內存管理的主要工作就是對物理內存進行組織，然后對物理內存的分配和回收。但是Linux引入了虛擬地址的概念。

2023-08-31 14:46:51

378

查看Linux系統內存使用情況的幾種方法

在Linux系統中，內存監控是優化系統性能的關鍵。本文為你介紹12種方法，幫助你全面掌握Linux系統的內存使用情況。這些方法包括查看/proc/meminfo、使用atop、free、GNOME System Monitor等工具，讓你快速獲取有關物理內存、交換空間、緩沖區和緩存區等信息。

2023-11-13 09:30:39

1511

Linux內核內存管理架構解析

內存管理子系統可能是linux內核中最為復雜的一個子系統，其支持的功能需求眾多，如頁面映射、頁面分配、頁面回收、頁面交換、冷熱頁面、緊急頁面、頁面碎片管理、頁面緩存、頁面統計等，而且對性能也有很高

2024-01-04 09:24:37

280

Linux 內存管理知識學習經驗總結

現在的服務器大部分都是運行在Linux上面的，所以，作為一個程序員有必要簡單地了解一下系統是如何運行的。對于內存部分需要知道：地址映射內存管理的方式缺頁異常先來看一些基本的知識，在進程看來，內存分為

2016-02-25 17:08:44

Linux內存系統---走進Linux 內存

Linux內存系統---走進Linux 內存 1、內存是什么？1)內存又稱主存，是 CPU 能直接尋址的存儲空間，由半導體器件制成2)內存的特點是存取速率快2、內存的作用· 1)暫時存放 cpu

2020-08-26 08:05:43

Linux內存系統： Linux 內存分配算法

· 盡量一次性申請較大的內存，而不要反復申請小內存· 盡可能申請大塊的 2 的指數冪大小的內存空間· 外部碎片避免——伙伴系統算法· 內部碎片避免——slab 算法· 自己進行內存管理工作，設計內存池2

2020-08-24 07:44:49

Linux內存系統：內存使用場景

· shmdt 將共享內存從當前進程中分離Linux內存系統：五、內存使用那些坑1、C 內存泄露· 在類的構造函數和析構函數中沒有匹配地調用 new 和 delete 函數· 沒有正確地清除嵌套的對象

2020-08-25 07:42:08

Linux系統中磁盤管理是什么

Linux系統中的磁盤管理

2020-05-11 15:29:17

Linux系統移植篇6：STM32MP1微處理器之Linux內核簡介

可以完全訪問硬件。Linux內的設備驅動程序可以方便地以模塊化（Modularize）的形式設置，并在系統運行期間可直接裝載或卸載。Linux內核主要功能包括：進程管理、內存管理、文件管理、設備管理

2021-08-30 16:22:04

Linux上對進程進行內存分析和內存泄漏定位

在Linux產品開發過程中，通常需要注意系統內存使用量，和評估單一進程的內存使用情況，便于我們選取合適的機器配置，來部署我們的產品。Linux本身提供了一些工具方便我們達成這些需求，查看進程實時資源

2019-07-09 08:15:30

Linux內核之系統調用

Linux內核之系統調用1. 應用程序通過API而不是直接調用系統調用來編程；2. getpid()系統調用示例：asmlinkage long sys_getpid(void){ return

2012-02-21 10:49:32

Linux內核新增的異構內存管理會帶來什么不一樣？

Linux 內核新增的異構內存管理（HMM）會帶來什么不一樣？

2021-02-24 07:20:22

Linux電源管理的系統架構和驅動

驅動篇：inux 電源管理的系統架構和驅動（一）Linux 電源管理的全局架構Linux 在消費電子領域的應用已經相當普遍,而對于消費電子產品而言,省電是一個重要的議題。Linux 電源管理非常復雜

2022-01-03 06:36:44

Linux的進程管理

Linux之進程管理

2020-05-20 10:53:56

Linux虛擬內存管理技術的相關資料分享

嵌入式系統開發嵌入式系統開發工具進程控制Linux虛擬內存管理技術嵌入式系統開發工具進程控制1、定義：（1）、進程是可并發執行的程序，是一個在數據集合上的運行過程。（2）、當一個程序開始執行之后，在

2021-12-22 06:33:19

linux內存管理

公交，地鐵，睡前必備，方便大家查閱，持續更新，敬請期待！---更新于2020-02-12linux 內存管理：Linux的內存初始化CPU是如何訪問...

2021-07-22 08:41:07

linux的內存釋放操作

在Linux系統下，我們一般不需要去釋放內存，因為系統已經將內存管理的很好。但是凡事也有例外，有的時候內存會被緩存占用掉，導致系統使用SWAP空間影響性能，此時就需要執行釋放內存（清理緩存）的操作

2019-07-26 07:05:04

Mini Linux

Mini Linux EMMC

2023-03-28 13:06:25

RT-Thread系統動態內存堆有哪幾種管理算法呢

每種 RTOS 均有內存管理機制，RT-Thread 的內存管理分為兩類：動態內存堆管理、內存池管理。本篇文章先來介紹一下動態內存堆管理相關的內容。內存堆管理機制RT-Thread 操作系統在內存

2022-03-31 13:53:33

《深入理解LINUX內存管理》學習筆記

《深入理解LINUX內存管理》學習筆記1

2016-11-07 10:20:16

【北京迅為iMX6ULL】嵌入式學習之Linux系統編程視頻教程

怎么學習Linux系統編程框架學習方法、內核向用戶空間提供的接口或者說是函數，系統調用接口，學習這些接口的功能以及相關的參數和返回值等。嵌入式學習之Linux系統編程視頻教程在線觀看：https

2021-03-01 14:29:57

【我們一起學Linux之準備篇】善用佳軟Vmware安裝Linux系統

不習慣雙系統的使用，所以選擇使用虛擬機來進行Linux相關內容的學習，大家喜歡用什么類型的版本，也歡迎跟帖展示你們的安裝方法，拓寬大家的思路，有積分的哦~【我們一起學Linux之準備篇】善用佳軟

2016-01-20 21:01:15

一文搞定Linux內存管理原理

&quot;，讓其崩潰；如果是，則分配一個物理頁，并為之建立映射。物理內存管理(圖：右上)那么物理內存是如何分配的呢？首先，linux支持NUMA（非均質存儲結構），物理內存管理的第一個

2022-06-28 10:05:56

什么是嵌入式操作系統內存管理技術？

1 概述內存管理是操作系統的中心任務之一。內存管理模塊通常是操作系統內核的一部分，其主要任務是為操作系統內核和各執行程序組織內存，跟蹤當前內存使用狀況，在需要時為進程分配內存，使用完畢后釋放并回

2019-07-30 07:19:11

合理的使用linux系統的內存

關注、星標公眾號，不錯過精彩內容來源：EDN電子技術設計linux 內存是后臺開發人員，需要深入了解的計算機資源。合理的使用內存，有助于提升機器的性能和穩定性。本文主要介紹 linux ...

2021-12-17 07:40:45

基于Buddy算法的內存管理有什么優勢？

內存管理是操作系統的中心任務之一，其主要任務是組織內存以容納內核和待執行程序，跟蹤當前內存的使用情況，在需要時為進程分配內存，使用完畢后釋放并回收內存。目前嵌入式系統中常用的內存管理策略主要有兩種——靜態內存分配和動態內存分配。

2019-08-20 06:15:43

嵌入式Linux內存管理的一些知識點總結

內核處理異常)?？偨Y一句：這樣可以避免不必要的內存頁面復制的開銷。對CPU的內存管理(MMU)和linux系統的內存管理兩者的理解：上面的一段話，其實是告訴我們：在CPU提供MMU的情況下(也就是分段

2018-03-24 09:31:38

嵌入式Linux內存管理的一些知識點總結

內核處理異常）?？偨Y一句：這樣可以避免不必要的內存頁面復制的開銷。對CPU的內存管理（MMU）和linux系統的內存管理兩者的理解：上面的一段話，其實是告訴我們：在CPU提供MMU的情況下

2017-11-20 14:46:39

嵌入式Linux內存管理的知識

這個內存管理的知識點還真的需要我們專門的去理解一下，今天大家一起來學習學習嵌入式Linux內存管理的知識。

2021-02-03 06:30:19

嵌入式Linux內存管理知識點

這個內存管理的知識點還真的需要我們專門的去理解一下，今天大家一起來學習學習嵌入式Linux內存管理的知識。

2021-03-04 06:22:50

嵌入式Linux中的內存管理是什么

點擊嵌入式 Linux 中的內存管理

2021-11-05 07:01:15

嵌入式linux內核的五個子系統

和消息傳遞。 Linux內核的5個組成部分之間的依賴關系如下。 ·進程調度與內存管理之間的關系：這兩個子系統互相依賴。在多道程序環境下，程序要運行必須為之創建進程，而創建進程的第一件事情，就是將程序和數據裝入內存

2013-09-10 14:09:56

嵌入式系統內存管理

固定分配，而是根據系統需要而動態分配的，如果利用非虛擬內存管理機制，一般需要改造動態內存分配機制以提高性能。 4、內存管理的具體應用：A、Linux系統的內存管理機制Linux內存管理機制中，X86

2016-09-17 19:40:05

嵌入式系統裸機編程的內存管理

2021-04-02 06:18:07

嵌入式操作系統內存管理技術是什么？

2021-04-28 06:07:53

操作系統對于內存的管理

操作系統如何有效的管理內存便顯得尤為重要。本文講述操作系統對于內存的管理的過去和現在，以及一些頁替換的算法的介紹。

2019-08-07 06:53:09

淺析SoC中斷與Linux內存管理

什么是SoC中斷？Linux內存管理包括哪些？linux的進程調度時機有哪些？

2021-11-30 06:18:19

深入細節的詳解，嵌入式必懂知識之Linux內存管理

多干預而充分依靠自覺就可以有條不紊地運作，理想是美好的，現實是殘酷的。在linux系統中如果以一種原始簡單的方式管理內存是存在一些問題的，我們來看幾個場景。2.1 內存管理的問題進程空間隔離問題假如現在

2020-08-28 10:34:34

虛擬內存管理的地址是怎么分配的

看書時看到了linux的虛擬內存管理：中間有用戶虛擬地址，物理地址，總線地址，內核邏輯地址，內核虛擬地址等，這些地址是怎么分配的，有什么關系：；物理地址是sdram的地址空間嗎？簡單通俗講講內存管理吧，謝謝！

2019-05-22 05:45:32

郝健Linux內存管理學習筆記分享

郝健 Linux內存管理學習筆記-第3節課

2020-06-10 08:55:58

一種嵌入式系統內存管理的延遲合并伙伴機制

為提高嵌入式系統動態存儲管理機制的運行效率，確定時間開銷，該文在分析經典伙伴系統的基礎上，提出了延遲合并的方法，并輔以碎片整理及位圖機制。通過仿真試驗效果分析

2008-11-20 11:54:52

Linux內存管理中的Slab分配機制

早期Linux 的內存分配機制采用伙伴算法, 當請求分配的內存大小為幾十個字節或幾百個字節時會產生內存碎片, 嚴重消耗系統資源?，F今采用Slab 機制可以緩存物理空間的申請和回

2009-04-24 10:49:30

linux存儲器管理

linux存儲器管理本章主要講解了存儲器管理的基本方式，剖析了Linux 操作系統對內存的管理模式。通過對本章學習，讀者應該達到以下學習目標：重

2009-04-28 15:01:13

μClinux內存管理分析

laClinux內存管理采用非標準Linux內存模型。系統為進程分配連續內存區域，代碼段、數據段和棧段間無空隙，且進程私有堆被取消，所有進程共享由操作系統管理的堆空間。最簡單

2010-09-25 16:33:17

Linux系統管理技術手冊—奈米斯

本書為奈米斯所著的 Linux 系統管理技術手冊第二版。共從二十四個章節講述了Linux系統管理技術。適合Linux系統的入門者學習。

2011-08-10 14:16:51

Linux內存管理導讀

Linux 內存管理導讀 :1. 存儲層次結構和 x86存儲管理硬件（MMU） 1.1 存儲層次高速緩存(cache) 主存(main memory) 磁盤(disk) 理解存儲層次結構的根源：CPU速度和存儲器速度的差距。層次結構可

2011-11-03 22:32:33

linux內存管理機制淺析

本內容介紹了arm linux內存管理機制，詳細說明了linux內核內存管理,linux虛擬內存管理,arm linux內存管理等方面的知識

2011-12-19 14:09:27

LINUX源代碼分析-內存管理

操作系統管理系統所有的物理空間, 現代大多數操作系統都采取多級管理, 即頁面級分配與內核內存分配。就LINUX2-2-5 版本而言，頁面級的分配是采用Buddy 算法，而內核內存分配是采用面

2011-12-19 16:38:13

102

深入理解Linux虛擬內存管理_愛爾蘭/戈爾曼著

電子發燒友網站提供《深入理解Linux虛擬內存管理_愛爾蘭/戈爾曼著.txt》資料免費下載

2015-02-09 15:19:27

linux內存管理

linux內存管理

2017-10-24 11:12:13

Linux磁盤存儲區管理原理分析及技巧匯總

是什么 Linux 中的交換空間（Swap space）在物理內存（RAM）被充滿時被使用。如果系統需要更多的內存資源，而物理內存已經充滿，內存中不活躍的頁就會被移到交換空間去。雖然交換空間可以為帶有少量內存的機器提供幫助，但是這種方法不應該被當做是對內存的取代

2017-11-07 10:14:45

Linux系統內存管理的特點詳解

在Windows下資源管理器查看內存使用的情況，如果使用率達到80%以上，再運行大程序就能感覺到系統不流暢了，因為在內存緊缺的情況下使用交換分區，頻繁地從磁盤上換入換出頁會極大地影響系統的性能。

2017-12-01 14:38:15

3667

Linux資料匯總之內存管理

網絡上面有很多坑爹的文章，坑了不少人，很多人對Linux的很多誤解可能來自于這些廣泛流傳的技術文章。下面我們推出一個系列來總結。先從內存管理開始。

2018-03-27 11:39:19

4106

基于Linux內存管理與Android內存分配機制

Android采取了一種有別于Linux的進程管理策略，有別于Linux的在進程活動停止后就結束該進程，Android把這些進程都保留在內存中，直到系統需要更多內存為止。這些保留在內存中的進程通常情況下不會影響整體系統的運行速度，并且當用戶再次激活這些進程時，提升了進程的啟動速度。

2018-03-30 14:52:28

5987

嵌入式Linux內存管理的知識匯總

這個內存管理的知識點還真的需要我們專門的去理解一下，今天大家一起來學習學習嵌入式Linux內存管理的知識。 1.不涉及linux內核的匯編知識，僅C語言層面解析 1.回答：匯編主要處理的是寄存器地址

2018-04-09 05:58:00

887

如何避免Linux的物理內存碎片化

Linux buddyy系統是linux kernel比較穩定的一個模塊，但是并不是說它沒有缺陷，Linux內存管理系統自誕生之日，就一直存在物理內存碎片化的問題：在系統啟動并且運行很長一段時間

2018-05-01 16:43:00

5201

如何管理Linux 的內存分頁？

內存是計算機的主存儲器。內存為進程開辟出進程空間，讓進程在其中保存數據。我將從內存的物理特性出發，深入到內存管理的細節，特別是了解虛擬內存和內存分頁的概念。

2018-07-28 08:24:50

3588

Linux系統管理命令整理及使用方法介紹

linux命令是對Linux系統進行管理的命令。對于Linux系統來說，無論是中央處理器、內存、磁盤驅動器、鍵盤、鼠標，還是用戶等都是文件，Linux系統管理的命令是它正常運行的核心，與之前的DOS命令類似。linux命令在系統中有兩種類型：內置Shell命令和Linux命令。

2018-09-23 14:55:00

6594

Linux操作系統實用教程之如何Linux系統的遠程管理

本文檔的主要內容詳細介紹的是Linux操作系統實用教程之如何Linux系統的遠程管理主要內容是：1 遠程管理簡介2 終端方式的字符界面遠程管理3 B/S方式的遠程管理4 C/S方式的遠程桌面管理5 遠程管理方式的性能比較

2018-10-31 18:04:22

你知道linux內存管理基礎及方法？

linux的內存管理采取的分頁存取機制，會將內存中不經常使用的數據塊交換到虛擬內存中。linux會不時地進行頁面交換操作，以保持盡可能多的空閑物理內存，即使并沒有什么事需要內存，linux也會交換出暫時不用的內存頁面。

2019-04-28 17:12:07

992

你知道linux kernel內存碎片防治技術？

Linux kernel組織管理物理內存的方式是buddy system（伙伴系統），而物理內存碎片正式buddy system的弱點之一，為了預防以及解決碎片問題，kernel采取了一些實用技術，這里將對這些技術進行總結歸納。

2019-05-10 10:59:49

805

了解并學習Linux內存模型

model，其實就是從cpu的角度看，其物理內存的分布情況，在linux kernel中，使用什么的方式來管理這些物理內存。

2019-05-12 09:44:00

565

適當了解Linux內存管理等問題

linux內存管理還是比較復雜的，其中牽扯到很多方面的知識，這篇小博文算是自己對于內存管理的一點點的總結

2019-05-13 10:10:15

444

需要了解Linux設備驅動的內存管理辦法

對于包含 MMU 的處理器而言， Linux 系統提供了復雜的存儲管理系統，使得進程所能訪問的內存達到 4GB。進程的 4GB 內存空間被分為兩個部分—用戶空間與內核空間。

2019-05-13 11:24:14

666

詳細介紹Linux 內存使用方法

Linux在內存管理上份為兩級，一級是線性區，類似于00c73000-00c88000，對應于虛擬內存，它實際上不占用實際物理內存；一級是具體的物理頁面，它對應我們機器上的物理內存。

2019-05-16 17:13:45

429

Linux性能及調優指南：內存架構

。Linux內存知道可用的內存頁的數量及位置。伙伴系統Linux內核通過一種被稱作伙伴系統的機制管理空閑頁。伙伴系統管理空閑頁并盡力為分配請求分配頁。它盡最大努力保持內存區域的連續。如果不考慮分散

2019-04-02 14:32:19

245

Linux下進程的內存結構

Linux操作系統采用虛擬內存管理技術，使得每個進程都有各自互不干涉的進程地址空間。該地址空間是大小為4GB的線性虛擬空間，用戶所看到和接觸到的都是該虛擬地址，無法看到實際的物理內存地址。利用這種

2020-06-01 09:17:03

1323

Linux操作系統知識講解：走進內存

Linux操作系統知識講解：走進內存

2020-08-28 10:30:27

2089

Linux操作系統知識講解：走進linux 內存地址空間

Linux操作系統知識講解：走進linux 內存地址空間

2020-08-28 10:45:10

4639

Linux操作系統知識講解：走進Linux 內存分配算法

Linux操作系統知識講解：走進Linux 內存分配算法

2020-08-28 10:57:25

5045

Linux操作系統知識講解：走進Linux 內存使用場景

Linux操作系統知識講解：走進Linux 內存使用場景

2020-08-28 11:04:10

2661

Linux操作系統知識講解：避免內存使用七大坑

Linux操作系統知識講解：避免內存使用七大坑

2020-08-28 11:12:26

2604

一文解析Linux內存系統

2020-09-01 10:46:13

2186

伙伴算法如何才能在Linux內核中實現應用及其改進

伙伴算法是內存管理的比較常用的算法之一。以Linux內存管理為基礎，闡述了Linux內核中關于伙伴算法的應用。同時也指出了伙伴算法在內存管理方面的不足之處，針對具體的情況提出了具體的改進方法，使得該算法在具體的條件下更加高效.

2021-03-04 14:37:55

分析Linux操作系統的內存

前言:在Linux上不像在Windows上看內存那樣方便,而且還有Swap這個新的概念,所以知道如何來看Linux內存還是有一定意義的

2021-03-31 16:43:24

1151

深入剖析Linux共享內存原理

在Linux系統中，每個進程都有獨立的虛擬內存空間，也就是說不同的進程訪問同一段虛擬內存地址所得到的數據是不一樣的，這是因為不同進程相同的虛擬內存地址會映射到不同的物理內存地址上。但有

2021-10-30 09:52:41

1908

嵌入式 Linux 中的內存管理

點擊嵌入式 Linux 中的內存管理

2021-11-02 10:36:02

Linux內核虛擬內存管理中的mmu_gather操作

本文講解Linux內核虛擬內存管理中的mmu_gather操作，看看它是如何保證刷tlb和釋放物理頁的順序的，又是如何將更多的頁面聚集起來統一釋放的。

2022-05-20 14:37:53

1542

Linux內存管理的基礎知識科普

Linux的內存管理可謂是學好Linux的必經之路，也是Linux的關鍵知識點，有人說打通了內存管理的知識，也就打通了Linux的任督二脈，這一點不夸張。有人問網上有很多Linux內存管理的內容

2022-06-08 15:24:09

1746

Linux內存管理體系介紹

內存是計算機最重要的資源之一，內存管理是操作系統最重要的任務之一。內存管理并不是簡單地管理一下內存而已，它還直接影響著操作系統的風格以及用戶空間編程的模式?？梢哉f內存管理的方式是一個系統刻入DNA的秉性。既然內存管理那么重要，那么今天我們就來全面系統地講一講Linux內存管理。

2022-08-08 09:28:32

1190

Linux系統的共享內存的使用

但有時候為了讓不同進程之間進行通信，需要讓不同進程共享相同的物理內存，Linux通過共享內存來實現這個功能。下面先來介紹一下Linux系統的共享內存的使用。

2022-11-14 11:55:03

933

Linux內核引導內存分配器的原理

Linux內核引導內存分配器使用的是伙伴系統算法。這種算法是一種用于動態內存分配的高效算法，它將內存空間劃分為大小相等的塊，然后將這些塊組合成不同大小的內存塊。

2023-04-03 14:52:49

222

Linux內存管理的詳細介紹分享

內存管理是計算機系統中負責管理系統內存資源的一種機制，主要包括內存分配、內存釋放、內存映射和虛擬內存管理等方面。它是計算機系統中非常重要的一個組成部分，能夠有效地提高系統的資源利用率和應用程序的性能。

2023-05-29 14:09:37

1356

Linux內核實現內存管理的基本概念

本文概述Linux內核實現內存管理的基本概念，在了解基本概念后，逐步展開介紹實現內存管理的相關技術，后面會分多篇進行介紹。

2023-06-23 11:56:00

478

Linux中內存管理子系統開發必知的3個結構概念

Linux中內存管理子系統使用節點（node）、區域（zone）和頁（page）三級結構描述物理內存。

2023-08-28 09:34:59

544

Linux 內存管理總結

一、Linux內存管理概述 Linux內存管理是指對系統內存的分配、釋放、映射、管理、交換、壓縮等一系列操作的管理。在Linux中，內存被劃分為多個區域，每個區域有不同的作用，包括內核空間、用戶空間

2023-11-10 14:58:37

217

Linux內存管理之CPU本地頁幀緩存

在前一節中，我們學習了buddy伙伴關系系統，它適用于申請連續的大塊物理內存；而有些時候，經常需要申請和釋放單個頁幀。

2024-02-20 09:23:07

127

已全部加載完成

搜索歷史

Linux內存管理之伙伴系統

評論