Avez-vous déjà rencontré divers problèmes de mémoire dans les systèmes Linux ? Tels que les fuites de mémoire, la fragmentation de la mémoire, etc. Ces problèmes peuvent être résolus par une compréhension approfondie de la technologie de prévention de la fragmentation de la mémoire du noyau Linux.
La façon dont le noyau Linux organise et gère la mémoire physique est le système compagnon, et la fragmentation de la mémoire physique est l'une des faiblesses du système compagnon. Afin de prévenir et de résoudre le problème de fragmentation, le noyau a adopté certaines technologies pratiques. sera résumée ici.
Appliquer les pages mémoire de mon ami. Si aucune page appropriée n'est trouvée, deux étapes de réglage de la mémoire seront effectuées, compactées et récupérées. La première consiste à consolider des fragments pour obtenir une mémoire contiguë plus grande ; la seconde consiste à recycler la mémoire tampon qui n'occupe pas nécessairement de la mémoire. L'objectif ici est de comprendre comact. L'ensemble du processus est à peu près le suivant :
__alloc_pages_nodemask -> __alloc_pages_slowpath -> __alloc_pages_direct_compact -> try_to_compact_pages -> compact_zone_order -> compact_zone -> isolate_migratepages -> migrate_pages -> release_freepages 并不是所有申请不到内存的场景都会compact，首先要满足order大于0，并且gfp_mask携带__
GFP_FS et __GFP_IO ; De plus, la mémoire restante de la zone doit remplir certaines conditions. Le noyau l'appelle "l'indice de fragmentation". Cette valeur est comprise entre 0 et 1000. Le compactage ne peut être effectué que lorsque l'indice de fragmentation par défaut est supérieur. supérieur à 500. Cette valeur par défaut peut être ajustée via le fichier proc extfrag_threshold. L'indice de fragmentation est calculé grâce à la fonction fragmentation_index :
1. /* 2. \* Index is between 0 and 1000 3. * 4. \* 0 => allocation would fail due to lack of memory 5. \* 1000 => allocation would fail due to fragmentation 6. */ 7. return 1000 - div_u64( (1000+(div_u64(info->free_pages * 1000ULL, requested))), info->free_blocks_total)
Pendant le processus de consolidation des fragments de mémoire, les pages fragmentées ne se déplaceront que dans cette zone, et les pages situées aux adresses basses de la zone seront déplacées autant que possible vers la fin de la zone. La demande d'un nouvel emplacement de page est implémentée via la fonction compaction_alloc.
Le processus de mouvement est divisé en synchrone et asynchrone. Après l'échec de l'application de mémoire, le premier compactage utilisera l'asynchrone et la récupération ultérieure utilisera l'asynchrone. Le processus synchrone déplace uniquement les pages actuellement inutilisées, et le processus asynchrone parcourra et attendra que toutes les pages MOBILES soient utilisées avant de se déplacer.
Les pages mémoire sont divisées en trois types suivants en fonction de la mobilité :
INAMOVABLE : L'emplacement dans la mémoire est fixe et ne peut pas être déplacé à volonté. La mémoire allouée par le noyau appartient essentiellement à ce type ;
RÉCUPÉRABLE : ne peut pas être déplacé, mais peut être supprimé et recyclé. Par exemple, la mémoire mappée sur des fichiers ;
MOBILE : elle peut être déplacée à volonté. La mémoire de l'espace utilisateur appartient essentiellement à ce type.
Lors d'une demande de mémoire, demandez d'abord une mémoire dans le type de page libre spécifié en fonction de la mobilité. La mémoire libre de chaque zone est organisée comme suit :
1. struct zone {
2. ......
3. struct free_area free_area[MAX_ORDER];
4. ......
5. }
6.
7. struct free_area {
8. struct list_head free_list[MIGRATE_TYPES];
9. unsigned long nr_free;
10. };
Lorsque la mémoire ne peut pas être demandée dans la zone libre du type spécifié, elle peut être appropriée à partir du type de sauvegarde. La mémoire allouée sera libérée vers la liste de types nouvellement spécifiée. Le noyau appelle ce processus "vol".
La liste de priorité des types alternatifs est définie comme suit :
1. static int fallbacks[MIGRATE_TYPES][4] = {
2. [MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE, MIGRATE_RESERVE },
3. [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE, MIGRATE_RESERVE },
4. \#ifdef CONFIG_CMA
5. [MIGRATE_MOVABLE] = { MIGRATE_CMA, MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_RESERVE },
6. [MIGRATE_CMA] = { MIGRATE_RESERVE }, /* Never used */
7. \#else
8. [MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_RESERVE },
9. \#endif
10. [MIGRATE_RESERVE] = { MIGRATE_RESERVE }, /* Never used */
11. \#ifdef CONFIG_MEMORY_ISOLATION
12. [MIGRATE_ISOLATE] = { MIGRATE_RESERVE }, /* Never used */
13. \#endif
14. };
Il convient de noter que tous les scénarios ne conviennent pas à l'organisation des pages par mobilité. Lorsque la taille de la mémoire n'est pas suffisante pour être allouée à différents types, elle n'est pas adaptée pour activer la mobilité. Il existe une variable globale pour indiquer si elle est activée, qui est définie lors de l'initialisation de la mémoire :
1. void __ref build_all_zonelists(pg_data_t *pgdat, struct zone *zone)
2. {
3. ......
4. if (vm_total_pages else
7. page_group_by_mobility_disabled = 0;
8. ......
9. }
Si page_group_by_mobility_disabled, toute la mémoire est non mobile.
Il existe un paramètre qui détermine le nombre minimum de pages que possède chaque zone mémoire, pageblock_nr_pages, qui est défini comme suit :
#define pageblock_order HUGETLB_PAGE_ORDER
1. \#else /* CONFIG_HUGETLB_PAGE */ 2. /* If huge pages are not used, group by MAX_ORDER_NR_PAGES */ 3. \#define pageblock_order (MAX_ORDER-1) 4. \#endif /* CONFIG_HUGETLB_PAGE */ 5. \#define pageblock_nr_pages (1UL
Lors de l'initialisation du système, toutes les pages sont marquées MOBILE :
1. void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
2. unsigned long start_pfn, enum memmap_context context)
3. {
4. ......
5. if ((z->zone_start_pfn D'autres types de mobilité de pages sont générés ultérieurement, ce qui est le "vol" mentionné ci-dessus. Lorsque cela se produit, les pages contiguës de plus grande priorité et plus grandes dans la solution de secours sont généralement « volées » pour éviter la génération de petits fragments.
1. /* Remove an element from the buddy allocator from the fallback list */
2. static inline struct page *
3. __rmqueue_fallback(struct zone *zone, int order, int start_migratetype)
4. {
5. ......
6. /* Find the largest possible block of pages in the other list */
7. for (current_order = MAX_ORDER-1; current_order >= order;
8. --current_order) {
9. for (i = 0;; i++) {
10. migratetype = fallbacks[start_migratetype][i];
11. ......
12. }
Vous pouvez visualiser la distribution des différents types de pages dans le système actuel via /proc/pageteypeinfo.
Avant la technologie d'organisation des pages basée sur la mobilité, il existe une autre méthode qui a été intégrée au noyau, et c'est le domaine de mémoire virtuelle : ZONE_MOVABLE. L'idée de base est simple : diviser la mémoire en deux parties, amovible et non amovible.
1. enum zone_type {
2. \#ifdef CONFIG_ZONE_DMA
3. ZONE_DMA,
4. \#endif
5. \#ifdef CONFIG_ZONE_DMA32
6. ZONE_DMA32,
7. \#endif
8. ZONE_NORMAL,
9. \#ifdef CONFIG_HIGHMEM
10. ZONE_HIGHMEM,
11. \#endif
12. ZONE_MOVABLE,
13. __MAX_NR_ZONES
14. };
ZONE_MOVABLE的启用需要指定kernel参数kernelcore或者movablecore，kernelcore用来指定不可移动的内存数量，movablecore指定可移动的内存大小，如果两个都指定，取不可移动内存数量较大的一个。如果都不指定，则不启动。
与其它内存域不同的是ZONE_MOVABLE不关联任何物理内存范围，该域的内存取自高端内存域或者普通内存域。
find_zone_movable_pfns_for_nodes用来计算每个node中ZONE_MOVABLE的内存数量，采用的内存区域通常是每个node的最高内存域，在函数find_usable_zone_for_movable中体现。
在对每个node分配ZONE_MOVABLE内存时，kernelcore会被平均分配到各个Node：
kernelcore_node = required_kernelcore / usable_nodes;
在kernel alloc page时，如果gfp_flag同时指定了__GFP_HIGHMEM和__GFP_MOVABLE，则会从ZONE_MOVABLE内存域申请内存。
总之，Linux kernel内存碎片防治技术是一个非常重要的概念，可以帮助你更好地理解Linux系统中的内存管理。如果你想了解更多关于这个概念的信息，可以查看本文提供的参考资料。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
