start_kernel()
  |-->page_address_init()

  |

  |-->setup_arch(&command_line);

  |

  |-->setup_per_cpu_areas();

  |

  |-->build_all_zonelist()

  |

  |-->page_alloc_init()

  |

  |-->pidhash_init()

  |

  |-->vfs_caches_init_early()

  |

  |-->mm_init()

  |

  |-->.......

  |

  |-->gfp_allowed_mask = __GFP_BITS_MASK;

  |   在此之前，gfp_allowed_mask = GFP_BOOT_MASK;

  |

  |-->kmem_cache_init_late();

  |

void __init kmem_cache_init_late(void)

  |-->struct kmem_cache *cachep;

  |

  |-->list_for_each_entry(cachep, &cache_chain, next)

  |-->if (enable_cpucache(cachep, GFP_NOWAIT))  BUG();

  |

  |--g_cpucache_up = FULL;

  |

  |-->init_lock_keys();

  |

  |-->register_cpu_notifiler(&cpu_notifier);

int enabel_cpucache(struct kmem_cache *cachep, gfp_t gfp)

  |-->int limit;

  |

  |-->if (cachep->buffer_size > ) limit = ;

  |   else if (cachep->buffer_size > PAGE_SIZE) limit = ;

  |   else if (cachep->buffer_size > ) limit = ;

  |   else if (cachep->buffer_size > ) limit = ;

  |   else limit = ;

  |   为什么选择这些数值啊，不明白???

  |

  |-->int shared = ;

  |   if(cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > )

  |      shared = ;

  |

  |--int err = ;

  |  err = do_tune_cpucache(cachep, limit, (limit + ) / , shared, gfp);

  |

  |--return err;

int do_tune_cpucache(struct kmem_cache *cachep, int limit,

        int batchcount, int shared, gfp_t gfp)

  |-->struct ccupdate_struct *new = NULL;

  |   new = kazlloc(sizeof(*new), gfp);

  |

  |--int i;

  |--for_each_online_cpu(i)

  |--{

  |    new->new[i] = alloc_arraycache(cpu_to_node(i), limit,
  |                                    batchcount, gfp);

  |    根据limit, batchcount数值，构建新的array_cache实例.

  |

  |    因为kmem_cache中的array_cache是每个CPU的，所以此处是循环，为每个CPU都

  |    都构建一个array_cache实例.

  |--}

  |

  |-->new->cachep = cachep;

  |

  |-->on_each_cpu(do_ccupdate_local, (void*)new, );

  |   将kmem_cache下的每个CPU的array_cache[i]更换成new->new[i];

  |

  |-->cachep->batchcount = batchcount;

  |   cachep->limit = limit;

  |   cachep->shared = shared;

  |

  |

  |  上面以替换了kmem_cache下的每个CPU的array_cache[i],
  |  因此需要把原来的array_cache释放掉.

  |--for_each_online_cpu(i)

  |--{

  |    struct array_cache *ccolde = new->new[i];

  |    if(!ccold) continue;

  |

  |    free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));

  |    我们知道在此之前，ccold->avail一直为0，所以该函数暂时可以不看.

  |    此函数，就是把ccold->avail个ccole->entry中的数组元素指向的内存空间

  |    释放给slab管理器.

  |

  |

  |    kfree(ccold);

  |    基本同于free_block，我们知道slab所管理的内存都是位于低端内存，低端内存的物

  |    理地址及其对应的虚拟地址存在固定偏移，因此根据该部分的虚拟地址可以很容易的找到

  |    struct page实例，而struct page中的lru链表，在slab中被复用了,根据链表

  |    指针可以找到kmem_cache实例，所以kfree基本等同于free_block;

  |    但是kfree与free_block的重要的不同点在于,free_block直接将内存释放给了

  |    slab管理器，而kfree首选将内存释放给每CPU的array_cache数组.

  |

  |--}

  |-->kfree(new);

  |

  |--return alloc_kmemlist(cachep, gfp);

  |  每个kmem_cache中的kmem_list3.shared上array_cache可以被所有CPU共享.

我们知道kmem_cache中对于每CPU都有一个array_cache，已作为每CPU申请内存的缓存.

此函数的目的在于：每个kmem_cache都有一个kmem_list3实例，该实例的shared作为

一个kmem_cache上所有CPU的内存申请缓存(对于UMA，kmem_cache.alien没有用处).

此时，我们不妨猜测，当一个CPU通过kmalloc申请内内存时，将从kmem_cache实例上

自己的array_cache进行申请，如果没有则从kmem_list3->shared上补充到array_cache上，

如果kmem_list3上也每有，将从slab管理器上获取，充分体现了缓存的利用.

int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)

  |-->int node = ;

  |   struct kmem_list3 *l3 = NULL;

  |   struct array_cache *new_shared = NULL;

  |   struct array_cache **new_alien = NULL;

  |

  |-->for_each_online_node(node)

  |--{

  |    new_shared = NULL;

  |    if(cachep->shared)

  |        new_shared = alloc_arraycache(node,

  |                     cachep->shared * cachep->batchcount,

  |                     0xbaadf00d, gfp);

  |

  |

  |    l3 = cachep->nodelists[node];

  |    if(l3)

  |    |-{

  |    |    struct array_cache *shared = l3->shared;

  |    |    if(shared) 
  |    |         free_block(cachep, shared->entry, shared->avail, node);

  |    |    l3->shared = new_shared;

  |    |    if(!l3->alien) l3->alien = new_alien, new_alien = NULL;

  |    |    l3->free_limit = ( + NR_CPUS) * cachep->batchcount
  |    |                     + cachep->num;|    |    kfree(shared);

  |    |    free_alien_cache(new_alien);

  |    |    continue; //对于单节点，再次continue时，将退出循环

  |    |-}

  |    |

  |    |

  |    ...... 对于UMA体系 nothing

  |    |
  |--}
  |

  |--return ;

void do_ccupdate_local(void *info)

  |-->struct ccupdate_struct *new = info;

  |   struct array_cache *old = cpu_cache_get(new->cachep);

  |

  |-->new->cachep->array[smp_processor_id()] = 
  |                new->new[smp_processor_id];
  |   new->new[smp_processor_id()] = old;

struct array_cache *alloc_arraycache(int node, int entries,

        int batchcount, gfp_t gfp)

  |-->int memsize = sizeof(void *) * entries
  |                 + sizeof(struct array_cache);
  |   根据entries的数值，计算该分配的array_cache空间大小.

  |

  |-->struct array_cache *nc = NULL;

  |   nc = kmalloc_node(memsize, gfp, node);

  |   nc->avail = ;

  |   nc->limit = entries;

  |   nc->batchcount = batchcount;

  |   nc->touched = ;

  |   spin_lock_init(&nc->lock);

  |

  |-->return nc;