linux内存源码分析 - SLAB分配器概述

            cat /proc/slabinfo

            /*
             slab分配器中的SLAB高速缓存 
            */
            struct
             kmem_cache {
    
            /*
             指向包含空闲对象的本地高速缓存，每个CPU有一个该结构，当有对象释放时，优先放入本地CPU高速缓存中 
            */
            struct array_cache __percpu *cpu_cache;

/* 1) Cache tunables. Protected by slab_mutex *//* 要转移进本地高速缓存或从本地高速缓存中转移出去的对象的数量 */
    unsigned int batchcount;
    /* 本地高速缓存中空闲对象的最大数目 */
    unsigned int limit;
    /* 是否存在CPU共享高速缓存，CPU共享高速缓存指针保存在kmem_cache_node结构中 */
    unsigned int shared;

    /* 对象长度 + 填充字节 */
    unsigned int size;
    /* size的倒数，加快计算 */struct reciprocal_value reciprocal_buffer_size;

    
/* 2) touched by every alloc & free from the backend *//* 高速缓存永久属性的标识，如果SLAB描述符放在外部(不放在SLAB中)，则CFLAGS_OFF_SLAB置1 */
    unsigned int flags;        /* constant flags *//* 每个SLAB中对象的个数(在同一个高速缓存中slab中对象个数相同) */
    unsigned int num;        /* # of objs per slab *//* 3) cache_grow/shrink *//* 一个单独SLAB中包含的连续页框数目的对数 */
    unsigned int gfporder;

    /* 分配页框时传递给伙伴系统的一组标识 */
    gfp_t allocflags;

    /* SLAB使用的颜色个数 */
    size_t colour;            
    /* SLAB中基本对齐偏移，当新SLAB着色时，偏移量的值需要乘上这个基本对齐偏移量，理解就是1个偏移量等于多少个B大小的值 */
    unsigned int colour_off;    
    /* 空闲对象链表放在外部时使用，其指向的SLAB高速缓存来存储空闲对象链表 */struct kmem_cache *freelist_cache;
    /* 空闲对象链表的大小 */
    unsigned int freelist_size;

    /* 构造函数，一般用于初始化这个SLAB高速缓存中的对象 */void (*ctor)(void *obj);


/* 4) cache creation/removal *//* 存放高速缓存名字 */constchar *name;
    /* 高速缓存描述符双向链表指针 */struct list_head list;
    int refcount;
    /* 高速缓存中对象的大小 */int object_size;
    int align;


/* 5) statistics *//* 统计 */
#ifdef CONFIG_DEBUG_SLAB
    unsigned long num_active;
    unsigned long num_allocations;
    unsigned long high_mark;
    unsigned long grown;
    unsigned long reaped;
    unsigned long errors;
    unsigned long max_freeable;
    unsigned long node_allocs;
    unsigned long node_frees;
    unsigned long node_overflow;
    atomic_t allochit;
    atomic_t allocmiss;
    atomic_t freehit;
    atomic_t freemiss;
/* 对象间的偏移 */int obj_offset;
#endif /* CONFIG_DEBUG_SLAB */
#ifdef CONFIG_MEMCG_KMEM
    /* 用于分组资源限制 */struct memcg_cache_params *memcg_params;
#endif/* 结点链表，此高速缓存可能在不同NUMA的结点都有SLAB链表 */struct kmem_cache_node *node[MAX_NUMNODES];
};

            /*
             SLAB链表结构 
            */
            struct
             kmem_cache_node {
    
            /*
             锁 
            */
            
    spinlock_t list_lock;


            /*
             SLAB用 
            */
            
#ifdef CONFIG_SLAB
    
            /*
             只使用了部分对象的SLAB描述符的双向循环链表 
            */
            struct list_head slabs_partial;    /* partial list first, better asm code *//* 不包含空闲对象的SLAB描述符的双向循环链表 */struct list_head slabs_full;
    /* 只包含空闲对象的SLAB描述符的双向循环链表 */struct list_head slabs_free;
    /* 高速缓存中空闲对象个数(包括slabs_partial链表中和slabs_free链表中所有的空闲对象) */
    unsigned long free_objects;
    /* 高速缓存中空闲对象的上限 */
    unsigned int free_limit;
    /* 下一个被分配的SLAB使用的颜色 */
    unsigned int colour_next;    /* Per-node cache coloring *//* 指向这个结点上所有CPU共享的一个本地高速缓存 */struct array_cache *shared;    /* shared per node */struct alien_cache **alien;    /* on other nodes *//* 两次缓存收缩时的间隔，降低次数，提高性能 */
    unsigned long next_reap;    
    /* 0:收缩  1:获取一个对象 */int free_touched;        /* updated without locking */#endif/* SLUB用 */
#ifdef CONFIG_SLUB
    unsigned long nr_partial;
    struct list_head partial;
#ifdef CONFIG_SLUB_DEBUG
    atomic_long_t nr_slabs;
    atomic_long_t total_objects;
    struct list_head full;
#endif#endif

};

            struct
             page {
    
            /*
             First double word block 
            */
            /*
             用于页描述符，一组标志(如PG_locked、PG_error)，也对页框所在的管理区和node进行编号 
            */
            
    unsigned 
            long flags; /
    union {
        /* 用于页描述符，当页被插入页高速缓存中时使用，或者当页属于匿名区时使用 */struct address_space *mapping; 
        /* 用于SLAB描述符，指向第一个对象的地址 */void *s_mem;            /* slab first object */
    };


    /* Second double word */struct {
        union {
            /* 作为不同的含义被几种内核成分使用。例如，它在页磁盘映像或匿名区中标识存放在页框中的数据的位置，或者它存放一个换出页标识符 */
            pgoff_t index;        /* Our offset within mapping. *//* 用于SLAB描述符，指向空闲对象链表 */void *freelist;    
            /* 当管理区页框分配器压力过大时，设置这个标志就确保这个页框专门用于释放其他页框时使用 */bool pfmemalloc; 
        };

        union {
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
    defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
            /* Used for cmpxchg_double in slub *//* SLUB使用 */
            unsigned long counters;
#else/* SLUB使用 */
            unsigned counters;
#endifstruct {

                union {/* 页框中的页表项计数，如果没有为-1，如果为PAGE_BUDDY_MAPCOUNT_VALUE(-128)，说明此页及其后的一共2的private次方个数页框处于伙伴系统中，正在使用时应该是0 */
                    atomic_t _mapcount;

                    struct { /* SLUB使用 */
                        unsigned inuse:16;
                        unsigned objects:15;
                        unsigned frozen:1;
                    };
                    int units;    /* SLOB */
                };
                /* 页框的引用计数，如果为-1，则此页框空闲，并可分配给任一进程或内核；如果大于或等于0，则说明页框被分配给了一个或多个进程，或用于存放内核数据。page_count()返回_count加1的值，也就是该页的使用者数目 */
                atomic_t _count;        /* Usage count, see below. */
            };
            /* 用于SLAB时描述当前SLAB已经使用的对象 */
            unsigned int active;    /* SLAB */
        };
    };


    /* Third double word block */
    union {
        /* 包含到页的最近最少使用(LRU)双向链表的指针，用于插入伙伴系统的空闲链表中，只有块中头页框要被插入。也用于SLAB，加入到kmem_cache中的SLAB链表中 */struct list_head lru;    
/* SLAB使用 */struct {        /* slub per cpu partial pages */struct page *next;    /* Next partial slab */
#ifdef CONFIG_64BIT
            int pages;    /* Nr of partial slabs left */int pobjects;    /* Approximate # of objects */#elseshortint pages;
            shortint pobjects;
#endif
        };

        /* SLAB使用 */struct slab *slab_page; /* slab fields */struct rcu_head rcu_head;    /* Used by SLAB
                         * when destroying via RCU
                         */#if defined(CONFIG_TRANSPARENT_HUGEPAGE) && USE_SPLIT_PMD_PTLOCKS
        pgtable_t pmd_huge_pte; /* protected by page->ptl */#endif
    };


    /* Remainder is not double word aligned */
    union {
        /* 可用于正在使用页的内核成分(例如: 在缓冲页的情况下它是一个缓冲器头指针，如果页是空闲的，则该字段由伙伴系统使用，在给伙伴系统使用时，表明的是块的2的次方数，只有块的第一个页框会使用) */
        unsigned longprivate;        
#if USE_SPLIT_PTE_PTLOCKS
#if ALLOC_SPLIT_PTLOCKS
        spinlock_t *ptl;
#else
        spinlock_t ptl;
#endif#endif/* SLAB描述符使用，指向SLAB的高速缓存 */struct kmem_cache *slab_cache;    /* SL[AU]B: Pointer to slab */struct page *first_page;    /* Compound tail pages */
    };
#if defined(WANT_PAGE_VIRTUAL)
    /* 线性地址，如果是没有映射的高端内存的页框，则为空 */void *virtual;            /* Kernel virtual address (NULL if
                       not kmapped, ie. highmem) */#endif /* WANT_PAGE_VIRTUAL */
#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
    unsigned long debug_flags;    /* Use atomic bitops on this */#endif

#ifdef CONFIG_KMEMCHECKvoid *shadow;
#endif

#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
    int _last_cpupid;
#endif
}

    偏移量 = kmem_cache.colour_off * kmem_cache.node[NODE_ID].colour_next;

    kmem_cache.node[NODE_ID].colour_next++;
    if (kmem_cache.node[NODE_ID].colour_next == kmem_cache.colour)
        kmem_cache.node[NODE_ID].colour_next = 0;

            struct
             array_cache {
    
            /*
             可用对象数目 
            */
            
    unsigned 
            int
             avail;
    
            /*
             可拥有的最大对象数目，和kmem_cache中一样 
            */
            
    unsigned 
            int
             limit;
    
            /*
             同kmem_cache，要转移进本地高速缓存或从本地高速缓存中转移出去的对象的数量 
            */
            
    unsigned 
            int
             batchcount;
    
            /*
             是否在收缩后被访问过 
            */
            
    unsigned 
            int
             touched;
    
            /*
             伪数组，初始没有任何数据项，之后会增加并保存释放的对象指针 
            */
            void *entry[];    /*
};