// mm\page_alloc.c
...
static unsigned long __meminitdata arch_zone_lowest_possible_pfn[MAX_NR_ZONES];
static unsigned long __meminitdata arch_zone_highest_possible_pfn[MAX_NR_ZONES];
static unsigned long __initdata required_kernelcore;
static unsigned long __initdata required_movablecore;
static unsigned long __meminitdata zone_movable_pfn[MAX_NUMNODES];
...
/*
 * kernelcore=size sets the amount of memory for use for allocations that
 * cannot be reclaimed or migrated.
 */
static int __init cmdline_parse_kernelcore(char *p)
{
    return cmdline_parse_core(p, &required_kernelcore);
}

/*
 * movablecore=size sets the amount of memory for use for allocations that
 * can be reclaimed or migrated.
 */
static int __init cmdline_parse_movablecore(char *p)
{
    return cmdline_parse_core(p, &required_movablecore);
}

early_param("kernelcore", cmdline_parse_kernelcore);
early_param("movablecore", cmdline_parse_movablecore);

//設置外部碎片的閾值
root@ubuntu:/home/wy/misc/net# cat /proc/sys/vm/extfrag_threshold
500
//是否允許內部碎片整理移動不可回收的頁，1 允許
root@ubuntu:/home/wy/misc/net# cat /proc/sys/vm/compact_unevictable_allowed
1
//寫入任何值觸發(fā)內存碎片整理
root@ubuntu:/home/wy/misc/net# cat /proc/sys/vm/compact_memory 
cat: /proc/sys/vm/compact_memory: Permission denied

#include<bits/stdc++.h>
using namespace std;
/*進程分配內存塊鏈表的首指針*/
struct allocated_block *allocated_block_head = NULL;
#define PROCESS_NAME_LEN 32   /*進程名長度*/
#define MIN_SLICE    10             /*最小碎片的大小*/
#define DEFAULT_MEM_SIZE 1024     /*內存大小*/
#define DEFAULT_MEM_START 0       /*起始位置*/
/* 內存分配算法 */
#define MA_FF 1	//first fit
#define MA_BF 2
#define MA_WF 3
#define Buddy 4 //伙伴算法 
/*描述每一個空閑塊的數據結構*/
struct free_block_type{
    int size;
    int start_addr;
    struct free_block_type *next;
};  
typedef struct free_block_type FB;
/*指向內存中空閑塊鏈表的首指針*/
struct free_block_type *free_block;//此處盡量按內存地址順序排列 ，
/*每個進程分配到的內存塊的描述*/
struct allocated_block{
    int pid;    int size;
    int start_addr;
    char process_name[PROCESS_NAME_LEN];
    struct allocated_block *next;
};
typedef struct allocated_block allocated_block_type;
//buddy
typedef struct b_free_block_type
{
	int size;
	free_block_type *list;
	b_free_block_type *next;
}b_free_block_type;
b_free_block_type *b_free_block=NULL;//空的時候要設置為NULL 
//end of buddy 

typedef struct allocated_block AB;

int mem_size=DEFAULT_MEM_SIZE; /*內存大小*/
int ma_algorithm = Buddy;           /*當前分配算法*/ //------------------------>>>>>>>>> 
static int pid = 0;                                      /*初始pid*/
int flag = 0;                             /*設置內存大小標志*/


//init_free_block(int mem_size);
int display_mem_usage();
int b_creat_free_blocks(free_block_type *ab);
int rearrange_Buddy();
int rearrange(int algorithm);
int allocate_mem(struct allocated_block *ab); 
int free_mem(struct allocated_block *ab);
int dispose(struct allocated_block *free_ab);
int disfree(FB *free_ab);
void free_f();
void free_b();
/*初始化空閑塊，默認為一塊，可以指定大小及起始地址*/
struct free_block_type* init_free_block(int mem_size)
{
	free_f();
	free_b();
    struct free_block_type *fb;
    fb=(struct free_block_type *)malloc(sizeof(struct free_block_type));
    if(fb==NULL){
        printf("Error.\n");
        getchar();
        return NULL;
	}
    fb->size = mem_size;
    fb->start_addr = DEFAULT_MEM_START;
    fb->next = NULL;

    free_block=(struct free_block_type *)malloc(sizeof(struct free_block_type));
    *free_block=*fb;	//free_block供rearrange_Buddy使用，會被銷毀 
    rearrange_Buddy();//初始化buddy算法 
    return fb;	//會在main中重新賦值free_block 
}
/*顯示菜單*/
void display_menu(){
    printf("\n");
    printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);
    printf("2 - Select memory allocation algorithm\n");
    printf("3 - New process \n");
    printf("4 - Terminate a process \n");
    printf("5 - Display memory usage \n");
    printf("0 - Exit\n");
}
/*設置內存的大小*/
int set_mem_size(){	//只能設置一次, 清除現有所有鏈表，重新分配 
    int size;
    if(flag!=0){  //防止重復設置
        printf("Cannot set memory size again\n");
        return 0;
    }
    printf("Total memory size =");
    scanf("%d", &size);
    if(size>0) {
        mem_size = size;
       // free_block->size = mem_size;
        init_free_block(mem_size);
	    flag=1;   
		return 1;
    }
    cout<<"輸入不合法"<<endl;
    return 0;

}

/* 設置當前的分配算法 */
int set_algorithm(){
    int algorithm;
    printf("\t1 - First Fit\n");
    printf("\t2 - Best Fit \n");
    printf("\t3 - Worst Fit \n");
    printf("\t4 - Buddy \n"); 
    scanf("%d", &algorithm);
	//按指定算法重新排列空閑區(qū)鏈表
	if(algorithm==Buddy) 
   	{
   		if(ma_algorithm!=Buddy)
   			rearrange(algorithm); 	
	}
	else
	{
		if(ma_algorithm==Buddy)
			rearrange(algorithm); 	
	}
    if(algorithm>=1 && algorithm <=4)  
    {
    	ma_algorithm=algorithm;
        pid=0; 
	}
    else
    	cout<<"輸入錯誤!!!"<<endl;
    display_mem_usage();
}
/*按FF算法重新整理內存空閑塊鏈表*/
int rearrange_FF(){   
	//請自行補充
	//將buddy的二級制表示法展開，按地址排序 
	b_free_block_type *p=b_free_block;
	free_block_type *work,*twork;
	allocated_block_type *t=(allocated_block_type*)malloc(sizeof(allocated_block_type));	//最后要銷毀此臨時塊 
	//不排除其他函數調用此函數來完成內存列表的切換，需要暫時改變算法，結束之前再進行還原。
	int ma_algorithm_temp=ma_algorithm;//備份 
	ma_algorithm=MA_FF; //保證free_mem()的按照FF的方式工作 
	free_f();
	for(p=b_free_block;p!=NULL;p=p->next)
	{
		for(work=p->list;work!=NULL;work=work->next)//在f系列列表里增加內存而不銷毀b算法列表 
		{
			t->size=work->size;
			t->start_addr=work->start_addr;
			free_mem(t);	//不會刪除work
		}
	}
	//還原算法
	ma_algorithm=ma_algorithm_temp; 
	//不銷毀buddy.free內存列表 
	free(t);
}
/*按BF算法重新整理內存空閑塊鏈表*/
int rearrange_BF(){
	//請自行補充
	/*
	如果按地址排，則分配時復雜，free時方便
	如果按內存大小排，則分配時方便，free復雜
	綜合考慮，按地址排序還可以重用代碼，本程序選擇按地址排序 ——wbt 
	*/
	return rearrange_FF();
}
/*按WF算法重新整理內存空閑塊鏈表*/
int rearrange_WF(){
    //請自行補充
    return rearrange_FF();
}

int rearrange_Buddy()
{
	//盡量將ff，bf，wf的內存表示方式轉換（不足2的冪的補足，若無法補足返回0表示無法切換）
	//算了，太麻煩了還是按照只能開機設置設定吧。

	int i;
	free_b();
	b_free_block_type *p,*tp;//工作指針 
	p=b_free_block;
	while(p!=NULL) //釋放掉之前的 
	{
		tp=p->next;
		free(p);
		p=tp;
	}

	//將最大內存mem_size建立頭鏈表
	int size=1;
	while(size<mem_size)
		size<<=1;
	b_free_block=NULL;//頭插法，按從小到大排序 
	while(size)
	{
		p=(b_free_block_type*)malloc(sizeof(b_free_block_type));
		p->next=b_free_block;
		b_free_block=p;
		p->size=size;
		p->list=NULL;
		size>>=1;
	}
	//將free_block鏈表變換成b_free_block鏈表
	free_block_type *work,*twork;
	while(free_block!=NULL)	//邊轉換邊刪除 
	{
		work=free_block;
		free_block=free_block->next; 
		b_creat_free_blocks(work);	//新建一個 并插入 銷毀原來的free_block 
	}
	return 1;
}
//將free_block_type ab展開成buddy形式 銷毀原來的free_block 并進行合并檢查和操作 
int b_creat_free_blocks(free_block_type *ab)	//wbt class 3 grade 2016 
{
	b_free_block_type *p=b_free_block;
	free_block_type *work,*fwork,*twork;
	int i=0;
	while(p!=NULL && ab->size)
	{
		if(ab->size>>i&1)
		{
			if(p->list==NULL)//如果還沒有節(jié)點，則添加一個新節(jié)點 
			{
				work=p->list=(free_block_type*)malloc(sizeof(free_block_type));
				work->size=p->size;
				ab->size-=work->size;
				work->start_addr=ab->start_addr;
				ab->start_addr+=work->size;

				work->next=NULL;
				continue;
			}
			//從列表里選取合適的位置插入并上尋找伙伴合并（保證列表按地址排序） 
			//兩個塊由一個塊分裂而來的伙伴條件：判斷地址是不是2的冪次就可以
			fwork=NULL;
			for(work=p->list;/*work!=NULL,此處要考慮掛在尾巴上*/;work=work->next)
			{

				if(work==NULL || work->start_addr > ab->start_addr)//把一部分(p->size)插在work和fwork之間 
				{	//找到了位置，準備插入節(jié)點

					twork=(free_block_type*)malloc(sizeof(free_block_type));//新增的塊不用free 
					twork->size = p->size;
					twork->start_addr=ab->start_addr;
					ab->start_addr+=p->size; //留下低地址的部分,帶著高地址部分繼續(xù)尋找插入點 
					ab->size-=p->size;
					if(work==NULL)//掛在尾巴上  twork插在fwork和NULL(wrok)之間 
					{//特點是work=NULL，fwork!=NULL
						fwork->next=twork;
						twork->next=NULL;
						//看看能不能和前面的合并 
						work=twork;//合并統一性要求 （因為work==NULL，所以將twork替換work，即相當于對next之后的不會改動） 

					}
					else if(work==p->list)//第一個（沒有前驅） 
					{//特點是fwork==NULL ,work==p->list不等于NULL 
						twork->next=p->list;
						p->list=twork;//頭插法直接插在頭部 
						//只檢查后面的能不能合并
					}
					else//有前驅和后繼  插在fwork之后，work之前 
					{//特點是fwork和work都不為NULL 
						twork->next=work;
						fwork->next=twork;
						//和前面合并 
					}
					//兩個塊由一個塊分裂而來的伙伴條件：判斷地址是不是2的冪次就可以

					//和前面合并 (如果有前驅的話)  合并fwork 和 twork 其中twork->next= work  fwork的地址必須是size*2的倍數 
					if(fwork!=NULL && fwork->size + fwork->start_addr==twork->start_addr && fwork->start_addr%(p->size<<1)==0)
					{
						fwork->next=twork->next;
						fwork->size+=twork->size;
						//刪除fwork,因為合并一定能向上冒泡
						if(p->list==fwork)//如果fwork為第一個 
						{
							p->list=fwork->next;//刪除第一個 
						}
						else
						{
							//twork初值為第一個 
							for(work=p->list;work->next!=fwork;work=twork->next)
								;
							//此時twork為fwork的前驅
							work->next=fwork->next;
						}
						b_creat_free_blocks(fwork);//遞歸調用 
						free(twork); 
					}
					//檢查后面的能不能合并(如果有后繼的話)
					if(twork->next!=NULL && twork->start_addr+twork->size == twork->next->start_addr && twork->start_addr%(p->size<<1)==0)						
					{
						work=twork->next;
						twork->next=work->next;
						twork->size+=work->size;
						//twork為新塊  現在要刪掉twork向上冒泡 
						if(twork==p->list)//如果twork是第一個，即沒有前驅
						{
							p->list=twork->next;
						}
						else
						{
							fwork->next=twork->next;
						}
						b_creat_free_blocks(twork);
						free(work);	//和后面的二合一  
					}
				//	free(twork);
					break;//break for
				}
				else//設置前驅，繼續(xù)尋找 
				{
					fwork=work;
				}
			}//end of for 
		}//end of if
		p=p->next;
		i++;
	}//end of while
	free(ab);
	ab=NULL;
	return 1;
}

/*創(chuàng)建新的進程，主要是獲取內存的申請數量*/
int new_process(){
    struct allocated_block *ab;
    int size;    int ret;
    ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));
    if(!ab) exit(-5);
    ab->next = NULL;
    pid++;
    sprintf(ab->process_name, "PROCESS-%02d", pid);
    ab->pid = pid;    
    printf("Memory for %s:", ab->process_name);
    scanf("%d", &size);
    if(size>0) ab->size=size;
    ret = allocate_mem(ab);  /* 從空閑區(qū)分配內存，ret==1表示分配ok*/

 /*如果此時allocated_block_head尚未賦值，則賦值*/
    if((ret==1) &&(allocated_block_head == NULL)){ 
        allocated_block_head=ab;
        return 1;        }
    /*分配成功，將該已分配塊的描述插入已分配鏈表*/
    else if (ret==1) {
        ab->next=allocated_block_head;//頭插法 
        allocated_block_head=ab;
        return 2;        }
    else if(ret==-1){ /*分配不成功*/
        printf("Allocation fail\n");
        free(ab);
        return -1;       
     }
    return 3;
    }
/*分配內存模塊*/
int allocate_mem(struct allocated_block *ab){	//ff bf
    struct free_block_type *fbt, *pre;
    int request_size=ab->size;
    fbt = pre = free_block;
    //根據當前算法在空閑分區(qū)鏈表中搜索合適空閑分區(qū)進行分配，分配時注意以下情況：
    // 1. 找到可滿足空閑分區(qū)且分配后剩余空間足夠大，則分割
    // 2. 找到可滿足空閑分區(qū)且但分配后剩余空間比較小，則一起分配
    // 3. 找不可滿足需要的空閑分區(qū)但空閑分區(qū)之和能滿足需要，則采用內存緊縮技術，進行空閑分區(qū)的合并，然后再分配
    // 4. 在成功分配內存后，應保持空閑分區(qū)按照相應算法有序
    // 5. 分配成功則返回1，否則返回-1
	// 請自行補充。。。。。
	if(ma_algorithm==MA_FF)	//FF	從低地址往高地址分配 
	{
		for(FB* p=free_block;p!=NULL;p=p->next)
		{
			if(p->size >= request_size)//遇到即分配  FF
			{
				ab->start_addr=p->start_addr;
				p->start_addr+=request_size;
				p->size-=request_size;
				if(p->size<MIN_SLICE)
				{
					ab->size+=p->size;
					//刪除free block 
					disfree(p); 
				}
				/*		從高往低 
				ab->start_addr=p->start_addr;
				p->size-=request_size;
				*/
				return 1;
			}
		}
		printf("FF裝載失敗\n");
		return 0;
	}
	else if(ma_algorithm==MA_BF)//free block按地址排 
	{
		FB *p=free_block;
		FB *mini;
		int minv;
		int fg=0; 
		for(;p!=NULL;p=p->next)//遍歷找到差距最小能裝載的free block    從低地址開始裝載 
		{
			if(p->size>=request_size)
			{
				if(fg==0)
				{
					minv=p->size - request_size;
					mini=p; 
					fg=1;
				}
				else
				{
					if(p->size-request_size<minv)
					{
						minv=p->size-request_size;
						mini=p;
					}
				}
			}

		}
		if(fg)
		{
			//ab 為要分配的
			ab->start_addr=mini->start_addr;
			mini->start_addr+=request_size;
			mini->size-=request_size;
			if(mini->size<MIN_SLICE)
			{
				ab->size+=mini->size;
				//刪除free block 
				disfree(mini); 
			}
			return 1;
		}
		printf("BF裝載失敗\n");
		return 0;
	}
	else if(ma_algorithm==MA_WF) //free block按地址排 
	{
		FB *p=free_block;
		FB *maxi;
		int maxv;
		int fg=0; 
		for(;p!=NULL;p=p->next)//遍歷找到差距最小能裝載的free block    從低地址開始裝載 
		{
			if(p->size>=request_size)
			{
				if(fg==0)
				{
					maxv=p->size - request_size;
					maxi=p; 
					fg=1;
				}
				else
				{
					if(p->size-request_size>maxv)
					{
						maxv=p->size-request_size;
						maxi=p;
					}
				}
			}
		}
		if(fg)
		{
			//ab 為要分配的
			ab->start_addr=maxi->start_addr;
			maxi->start_addr+=request_size;
			maxi->size-=request_size;
			if(maxi->size<MIN_SLICE)
			{
				ab->size+=maxi->size;
				//刪除free block 
				disfree(maxi);
			}
			return 1;
		}
		printf("WF裝載失敗\n");
		return 0;
	}
	else if(ma_algorithm==Buddy)
	{
		if((ab->size)&(ab->size-1))
		{
			long long i=1;
			//不是2的冪次  將ab->size向上尋找一個2的冪次 
			for(;i<ab->size;i<<=1)
				;
			ab->size=i;
		}
		//從b_free_block中從小到大找到一個能裝下的2的次方
		b_free_block_type *p=b_free_block;
		while(p!=NULL)
		{
			if(p->size>=ab->size && p->list!=NULL)
			{
				break;
			}
			p=p->next;
		}

		if(p!=NULL)//找到了可用塊
		{
			//list按照地址排序的，現在按小地址優(yōu)先的原則分配
			free_block_type *work=p->list;
			work->size-=ab->size;
			ab->start_addr=work->start_addr;
			work->start_addr+=ab->size;

			p->list=work->next;
			b_creat_free_blocks(work);	//將剩余的分割掛在鏈表合適位置 
			return 1;
		}
		else
		{
			printf("Buddy裝載失敗\n"); 
			return 0;
		}
	}//end of buddy
//	return 1;
}

struct allocated_block* find_process(int pid)
{
	int i;
	struct allocated_block *p=allocated_block_head;
	for(;p!=NULL;p=p->next)
	{
		if(p->pid==pid)
			return p;
	}
	return NULL;
}
/*刪除進程，歸還分配的存儲空間，并刪除描述該進程內存分配的節(jié)點*/
int kill_process(){
    struct allocated_block *ab;
    int pid;
    printf("Kill Process, pid=");
    scanf("%d", &pid);
    ab=find_process(pid);
    if(ab!=NULL){
        free_mem(ab); /*釋放ab所表示的分配區(qū)*/
        dispose(ab);  /*釋放ab數據結構節(jié)點*/
    }
    else
    {
    	cout<<"不存在"<<endl; 
	}
}
/*將ab所表示的已分配區(qū)歸還，并進行可能的合并*/
int free_mem(struct allocated_block *ab){	//不會刪除ab 
    struct free_block_type *fbt=NULL, *pre, *work;
  //  fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
  //  if(!fbt) return -1;
    // 進行可能的合并，基本策略如下
    // 1. 將新釋放的結點插入到空閑分區(qū)隊列末尾
    // 2. 對空閑鏈表按照地址有序排列
    // 3. 檢查并合并相鄰的空閑分區(qū)
    // 4. 將空閑鏈表重新按照當前算法排序   /->  本程序不做次操作 
    //請自行補充……

    if(ma_algorithm==MA_FF || ma_algorithm== MA_BF || ma_algorithm== MA_WF)//free鏈表都是按地址排序,所以可以用同一種方式free 
    {
    	FB *fp=NULL,*p=NULL;
    	for(p=free_block;p!=NULL && p->start_addr < ab->start_addr;p=p->next)//尋找block屬于哪一個free block 
    	{
    		fp=p;
    			//前一個小于，后一個大于 
		}
		//fp為前一個free_block  ab為當前要free的block  p為下一個 
		if(fp!=NULL && fp->start_addr+fp->size==ab->start_addr)
		{	//當前面還有東西，就往前合并。。。，//???但如果，已經是最低地址的塊了 就不往前找了 我好像說了個廢話 ???
			fp->size+=ab->size;
			//fp為前面的塊，p為后面的塊 
			printf("和前一個合并\n");//不新增free_blocks
			if(p!=NULL && p->start_addr == fp->start_addr + fp->size)//用前面的free block嘗試往后合并 
			{
			//	fp->start_addr = p->start_addr;
				fp->size += p->size;
				fp->next=p->next; 
				free(p);//前后合并，刪除后面的free block 
				printf("和后一個合并"); 
				return 1;
			}
			return 1;
		}
		else if(p!=NULL && p->start_addr == ab->start_addr + ab->size)//嘗試往后合并	p為后面的 
		{
			p->start_addr = ab->start_addr;
			p->size += ab->size;
			printf("和后一個合并");
			return 1;
		}
		//無法合并，直接釋放，free鏈表插入節(jié)點 fp為前一個，p為后一個 fbt為新的free block 
	//	display_mem_usage();
		fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
		fbt->size=ab->size;
		fbt->start_addr=ab->start_addr;
		fbt->next=p;
		if(fp==NULL)
		{
			fbt->next=free_block;//頭插法 
			free_block=fbt;
		}
		else
		{
			fp->next=fbt;
		}
		printf("沒法合并,直接釋放");
	}
	else if(ma_algorithm==Buddy)
	{
		fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
  		if(!fbt) return -1;
  		fbt->size=ab->size;
  		fbt->start_addr=ab->start_addr;
  		return b_creat_free_blocks(fbt);//會銷毀fbt 
	}
    return 1;
}
/*釋放ab數據結構節(jié)點*/
int dispose(struct allocated_block *free_ab){
    struct allocated_block *pre, *ab;
   if(free_ab == allocated_block_head) { /*如果要釋放第一個節(jié)點*/
     allocated_block_head = allocated_block_head->next;
        free(free_ab);
        return 1;
        }
    pre = allocated_block_head;  
    ab = allocated_block_head->next;
    while(ab!=free_ab){ pre = ab;  ab = ab->next; }
    pre->next = ab->next;
    free(ab);
    return 2;
   }
int disfree(FB *free_ab){
    FB *pre, *ab;
   if(free_ab == free_block) { /*如果要釋放第一個節(jié)點*/
     free_block = free_block->next;
        free(free_ab);
        return 1;
        }
    pre = free_block;  
    ab = free_block->next;
    while(ab!=free_ab){ pre = ab;  ab = ab->next; }
    pre->next = ab->next;
    free(ab);
    return 2;
   }
/* 顯示當前內存的使用情況，包括空閑區(qū)的情況和已經分配的情況 */
int display_mem_usage(){
	if(ma_algorithm==Buddy)
	{
		cout<<"free blocks:"<<endl;
		b_free_block_type *p=b_free_block;
		while(p!=NULL)
		{
			printf("list:%d-----------<\n",p->size);
			free_block_type *work=p->list;
			while(work!=NULL)
			{
				printf("·start_adress:%-3d  size:%-3d\n",work->start_addr,work->size);
				work=work->next;
			}
			p=p->next;

		}
		 struct free_block_type *fbt=free_block;
		    struct allocated_block *ab=allocated_block_head;
			printf("\nUsed Memory:\n");
		    printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");
		    while(ab!=NULL){
	        printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);
	        ab=ab->next;
	        }
	}
    else 
    {
    	struct free_block_type *fbt=free_block;
	    struct allocated_block *ab=allocated_block_head;
	    if(fbt==NULL) return(-1);
	    printf("\tw.%s.t.\n","b"); 
	    printf("----------------------------------------------------------\n");

	    /* 顯示空閑區(qū) */
	    printf("Free Memory:\n");
	    printf("%20s %20s\n", "      start_addr", "       size");
	    while(fbt!=NULL){
	        printf("%20d %20d\n", fbt->start_addr, fbt->size);
	        fbt=fbt->next;
	        }    
	/* 顯示已分配區(qū) */
	    printf("\nUsed Memory:\n");
	    printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");
	    while(ab!=NULL){
	        printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);
	        ab=ab->next;
	        }
	    printf("----------------------------------------------------------\n");
	    return 0;
	}
}

	/*按指定的算法整理內存空閑塊鏈表*/
int rearrange(int algorithm){
    switch(algorithm){
        case MA_FF:  rearrange_FF(); break;
        case MA_BF:  rearrange_BF(); break;
        case MA_WF: rearrange_WF(); break;
        case Buddy:rearrange_Buddy();break;
		}
}
void free_f()
{
	struct allocated_block *f,*p;
	f=allocated_block_head;
	for(;f!=NULL;f=p)
	{
		p=f->next;
		free(f);
	}
	allocated_block_head=NULL;
	struct free_block_type *fn,*fp;
	fp=free_block;
	for(;fp!=NULL;fp=fn)
	{
		fn=fp->next;
		free(fp);
	}
	free_block=NULL;
}
void free_b()
{
	b_free_block_type *p,*tp;
	free_block_type *work,*t;
	p=b_free_block;
	while(p!=NULL)
	{
		tp=p;
		p=p->next;
		work=tp->list;
		while(work!=NULL)
		{
			t=work;
			work=work->next;
			free(t);
		}
		free(tp);
	}
	b_free_block=NULL;
}
void do_exit()
{
	free_f();
	free_b();
}

main(){
    char choice;      pid=0;
    free_block = init_free_block(mem_size); //初始化空閑區(qū)
    while(1) {
	    display_menu();	//顯示菜單
	    cout<<"當前算法編號:"<<ma_algorithm<<endl;
	    fflush(stdin);
	    choice=getchar();	//獲取用戶輸入
	    switch(choice)
		{
	        case '1': set_mem_size(); break; 	//設置內存大小   //開機只能設置一次，且只能在分配之前設置 
	        case '2': set_algorithm();flag=1; break;//設置算法
	        case '3': new_process(); flag=1; break;//創(chuàng)建新進程
	        case '4': kill_process(); flag=1;   break;//刪除進程
	        case '5': display_mem_usage();    flag=1; break;	//顯示內存使用
	        case '0': do_exit(); exit(0);	//釋放鏈表并退出
	        default: break;      
		}
	} 
}