The first stage, the physical memoruy info is collected, we setup the bitmap for all the memory in boot time. 

MMU_init[arch/ppc/kernel/head_fsl_booke.S:358] is called in stext. Here set_phys_avail is called to get physical memory info .

/* 

* Set phys_avail to the amount of physical memory,
* less the kernel text/data/bss.
*/


in setup_arch, do_init_bootmem used to initialize the bootmem bitmap 

min_low_pfn = start >> PAGE_SHIFT;

max_low_pfn = (PPC_MEMSTART + total_lowmem) >> PAGE_SHIFT;

max_pfn = (PPC_MEMSTART + total_memory) >> PAGE_SHIFT;

boot_mapsize = init_bootmem_node(&contig_page_data, min_low_pfn,

PPC_MEMSTART >> PAGE_SHIFT,

max_low_pfn);

According to phys_avail struct, the memory is freed in bootmem bitmap.

/* add everything in phys_avail into the bootmem map */

for (i = 0; i < phys_avail.n_regions; ++i)

free_bootmem(phys_avail.regions[i].address,

phys_avail.regions[i].size);

The second stage , we initizlize all the zones and all the page struct according to the amount of available memory, initialize the memmap (a global variable that used to point to all the page.)
Still in setup_arch, paging_init is called

free_area_init->free_area_init_node->free_area_init_core->init_currently_empty_zone->memmap_init->memmap_init_zone

in memmap_init_zone, all the pages is initialized and is set to reserved. 

The third stage:  in mem_init

mem_init->free_all_bootmem->free_all_bootmem_core 

free_all_bootmem_core: used to free the pages according to bootmem allocator , then bootmem allocator itself is also freed.

map = bdata->node_bootmem_map;

/* Check physaddr is O(LOG2(BITS_PER_LONG)) page aligned */

if (bdata->node_boot_start == 0 ||

ffs(bdata->node_boot_start) – PAGE_SHIFT > ffs(BITS_PER_LONG))

gofast = 1;

for (i = 0; i < idx; ) {

unsigned long v = ~map[i / BITS_PER_LONG];



if (gofast && v == ~0UL) {

int order;



page = pfn_to_page(pfn);

count += BITS_PER_LONG;

order = ffs(BITS_PER_LONG) – 1;

__free_pages_bootmem(page, order);

i += BITS_PER_LONG;

page += BITS_PER_LONG;

} else if (v) {

unsigned long m;



page = pfn_to_page(pfn);

for (m = 1; m && i < idx; m<<=1, page++, i++) {

if (v & m) {

count++;

__free_pages_bootmem(page, 0);

}

}

} else {

i += BITS_PER_LONG;

}

pfn += BITS_PER_LONG;

}
 

http://www.bestpractical.com/rt/

对于内存管理，uclinux有两套策略，在uClinux-dist\linux-2.4.x\mmnommu的目录下的Makefile文件就可以看出：
ifdef CONFIG_CONTIGUOUS_PAGE_ALLOC
obj-y += page_alloc2.o
else
obj-y += page_alloc.o
endif
如果没有定义CONFIG_CONTIGUOUS_PAGE_ALLOC，那么内存的管理是比较简单，所有的内存都是通过通用缓冲区来分配的，但 是内存管理的效率不高，浪费严重，对于内存非常少得系统来说，这样的策略是不可以接受的。当然设定 CONFIG_CONTIGUOUS_PAGE_ALLOC选项就可以使用连续分配页面的方法（不是伙伴算法，是一种简单的算法），但在uclinux中 是实验性的，我想也许还需要进一步的测试吧。我们可以从kmalloc的代码中看出些许端倪
void * kmalloc (size_t size, int flags)
{
cache_sizes_t *csizep = cache_sizes;

#ifdef CONFIG_CONTIGUOUS_PAGE_ALLOC
if (size >= PAGE_SIZE) {
unsigned long addr;
addr = __get_contiguous_pages(flags, (size+PAGE_SIZE-1)/PAGE_SIZE, 0);
return (void *)addr;
}
#endif

for (; csizep->cs_size; csizep++) {
if (size > csizep->cs_size)
continue;
return __kmem_cache_alloc(flags & GFP_DMA ?
csizep->cs_dmacachep : csizep->cs_cachep, flags);
}
return NULL;
}

没有定义CONFIG_CONTIGUOUS_PAGE_ALLOC的时候，所有的内存分配都是来自通用缓冲区，包括加载程序的时候，比如一个大 小为1.2M的程序，分配的内存会高达2M，其实即便加上bss段和stack段也需要不了那么多的内存，但是因为通用缓冲区的内存都是2的幂的级数，所 以1M下面就是2M的slab，而多余的空间被进程用来作堆，也就是进程中调用的malloc分配的内存就来自这些所谓的多余的空间。

对定义了CONFIG_CONTIGUOUS_PAGE_ALLOC的情况，同是通过一些全局的数据来控制内存的分配
static char *bit_map = NULL;—————–整个内存使用情况的位图
static int bit_map_size = 0;—————–位图的大小
static int first_usable_page = 0;————-第一个可用的页面
static int _nr_free_pages = 0; —————-总共空闲的页面的大小

具体的策略很简单，看看 __get_contiguous_pages和free_contiguous_pages即可

我觉得不完全正确,互斥手段的选择, 应该是根据临界区的大小, 临界区的性质以及竞争临界区的执行路径的数量这三个因数来同时决定.

首先, 如果竞争临界区的执行路径中存在interrupt handler的话, 那么只能选用spinlock且本地关中断的方法.

其次, 因为semaphore会导致进程上下文切换, 因此如果临界区也就一两百条指令, 也即属于短期互斥, 且竞争临界区的执行路径数量不多, 那么选用spinlock反而会比用semaphore的性能要好. 因为上下文切换本身就是一个很大的开销, 另外, 上下文切换后会使得cpu cache出险大量的cache miss. 从而使系统吞吐量下降.