歡迎您光臨本站 註冊首頁

一個簡單的內存管理程序

←手機掃碼閱讀     火星人 @ 2014-03-03 , reply:0

一個簡單的內存管理程序

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define PROCESS_NAME_LEN 32   /*進程名長度*/
#define MIN_SLICE    10             /*最小碎片的大小*/
#define DEFAULT_MEM_SIZE 1024     /*內存大小*/
#define DEFAULT_MEM_START 0       /*起始位置*/
/* 內存分配演算法 */
#define MA_FF 1
#define MA_BF 2
#define MA_WF 3
int mem_size=DEFAULT_MEM_SIZE; /*內存大小*/
int ma_algorithm = MA_FF;           /*當前分配演算法*/
static int pid = 0;                                      /*初始pid*/
int flag = 0;                                    /*設置內存大小標誌*/
/*描述每一個空閑塊的數據結構*/
struct free_block_type{
    int size;
    int start_addr;
    struct free_block_type *next;
};  
/*指向內存中空閑塊鏈表的首指針*/
struct free_block_type *free_block;
/*每個進程分配到的內存塊的描述*/
struct allocated_block{
    int pid;   
int size;
    int start_addr;
    char process_name;
    struct allocated_block *next;
};
/*進程分配內存塊鏈表的首指針*/
struct allocated_block *allocated_block_head = NULL;
/*初始化空閑塊,默認為一塊,可以指定大小及起始地址*/
struct free_block_type* init_free_block(int mem_size){
    struct free_block_type *fb;
struct allocated_block *p=allocated_block_head;

    fb=(struct free_block_type *)malloc(sizeof(struct free_block_type));
    if(fb==NULL){
        printf("No mem\n");
        return NULL;
}
    fb->size = mem_size;
while(p)
  p=p->next;
if(p==allocated_block_head)
  fb->start_addr = mem_size;
else
  fb->start_addr=mem_size-(p->size+p->start_addr);
// fb->start_addr = DEFAULT_MEM_START;
    fb->next = NULL;
    return fb;
}
display_menu();
int set_mem_size();
set_algorithm();
rearrange(int algorithm);
rearrange_FF();
rearrange_BF();
rearrange_WF();
new_process();
kill_process();
do_exit();
struct allocated_block *find_process(int pid);
int allocate_mem(struct allocated_block *ab);
int free_mem(struct allocated_block *ab);
int dispose(struct allocated_block *free_ab);
display_mem_usage();
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;
  free_block->start_addr=mem_size;
  flag=1;  
  return 1;
}
else
{
  printf("the size is erro!\n");
  return 0;
}
}
/* 設置當前的分配演算法 */
set_algorithm(){
    int algorithm;
    printf("\t1 - First Fit\n");
    printf("\t2 - Best Fit \n");
    printf("\t3 - Worst Fit \n");
    scanf("%d", &algorithm);
    if(algorithm>=1 && algorithm <=3)  
  ma_algorithm=algorithm;
//按指定演算法重新排列空閑區鏈表
    rearrange(ma_algorithm);
}
/*按指定的演算法整理內存空閑塊鏈表*/
rearrange(int algorithm){
    switch(algorithm){
case MA_FF:  rearrange_FF(); break;
case MA_BF:  rearrange_BF(); break;
case MA_WF: rearrange_WF(); break;
}
}
/*按FF演算法重新整理內存空閑塊鏈表*/
rearrange_FF(){
int size;
    int start_addr;
struct free_block_type *p, *q; //*free_block
p=q=free_block;
while(p)
{
  while(q)
  {
   if(p->size>q->size)
   {
    size=p->size;
    start_addr=p->start_addr;
    p->size=q->size;
    p->start_addr=q->start_addr;
    q->size=size;
    q->start_addr=start_addr;
   }
   q=q->next;
  }
  p=p->next;
}
//請自行補充
}
/*按BF演算法重新整理內存空閑塊鏈表*/
rearrange_BF(){
int size;
    int start_addr;
struct free_block_type *p, *q; //*free_block
p=q=free_block;
while(p)
{
  while(q)
  {
   if(p->size>q->size)
   {
    size=p->size;
    start_addr=p->start_addr;
    p->size=q->size;
    p->start_addr=q->start_addr;
    q->size=size;
    q->start_addr=start_addr;
   }
   q=q->next;
  }
  p=p->next;
}
//請自行補充

}
/*按WF演算法重新整理內存空閑塊鏈表*/
rearrange_WF(){
int size;
    int start_addr;
struct free_block_type *p, *q; //*free_block
p=q=free_block;
while(p)
{
  while(q)
  {
   if(p->size<q->size)
   {
    size=p->size;
    start_addr=p->start_addr;
    p->size=q->size;
    p->start_addr=q->start_addr;
    q->size=size;
    q->start_addr=start_addr;
   }
   q=q->next;
  }
  p=p->next;
}
//請自行補充

}
/*創建新的進程,主要是獲取內存的申請數量*/
new_process(){
    struct allocated_block *ab;
    int size;    int ret;
int j=0;
    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);  /* 從空閑區分配內存,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;      
}
//ab->start_addr=++j;
    return 3;
}
/*分配內存模塊*/
int allocate_mem(struct allocated_block *ab){
    struct free_block_type *fbt, *pre;
    int request_size=ab->size;
struct allocated_block *p,*q;
p=q=allocated_block_head;
fbt = pre = free_block;
while(q)
{
  q=q->next;
}

while(fbt)
{   
  pre=fbt->next;
  if(fbt->size-request_size<10&&fbt->size-request_size>0)
  {
   if(fbt==free_block)
   {
    ab->size=request_size;
    if(q==allocated_block_head)
     ab->start_addr=0;
    else
     ab->start_addr=p->start_addr+p->size;
    free_block=free_block->next;
    free(fbt);
    return 1;
   }
   else
   {
    ab->size=request_size;
    if(q==allocated_block_head)
     ab->start_addr=0;
    else
     ab->start_addr=p->start_addr+p->size;
    pre->next=fbt->next;
    free(fbt);
    return 1;
    break;
   }
  }
  else if(fbt->size-request_size>10)
  {
   ab->size=request_size;
   if(q==allocated_block_head)
    ab->start_addr=0;
   else
    ab->start_addr=p->start_addr+p->size;
   fbt->size-=request_size;
   switch(ma_algorithm)
   {
   case 1:
    {
     rearrange_FF();
     break;
    }
   case 2:
    {
     rearrange_BF();
     break;
    }
   case 3:
    {
     rearrange_WF();
     break;
    }
   }
   return 1;
  }
  fbt=fbt->next;
}
if(!fbt)
{
  // printf("沒有合適的空間!\n");
  return -1;
}
  return 0;
}
/*刪除進程,歸還分配的存儲空間,並刪除描述該進程內存分配的節點*/
struct allocated_block *find_process(int pid)
{
struct  allocated_block *p=allocated_block_head;
// p=allocated_block_head;struct allocated_block *allocated_block_head = NULL
while(p)           
  //判斷條件必須是p是否為空不能是p->next,因為如果只有一個節點時p->next=NULL,此時不能返回要刪除的節點
{
  if(p->pid==pid)
  {
   return p;
  }
  p=p->next;
}
return NULL;
}
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所表示的分配區*/
        dispose(ab);  /*釋放ab數據結構節點*/
}
}
/*將ab所表示的已分配區歸還,並進行可能的合併*/
void sort()
{
int size;
    int start_addr;
struct free_block_type *p, *q; //*free_block
p=q=free_block;
while(p)
{
  while(q)
  {
   if(p->start_addr >q->start_addr)
   {
    size=p->size;
    start_addr=p->start_addr;
    p->size=q->size;
    p->start_addr=q->start_addr;
    q->size=size;
    q->start_addr=start_addr;
   }
   q=q->next;
  }
  p=p->next;
}

}
int free_mem(struct allocated_block *ab){
    int algorithm = ma_algorithm;
    struct free_block_type *fbt, *pre;//*work;
fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
    if(!fbt) return -1;
else
{
  pre=free_block;
  fbt->size=ab->size;
  fbt->start_addr=ab->start_addr;
  while(pre->next)
   pre=pre->next;
  fbt->next=NULL;
  pre->next=fbt;
  switch(algorithm)
  {
  case 1:
   {
    sort();
    rearrange_FF();
    break;
   }
  case 2:
   {
    sort();
    rearrange_BF();
    break;
   }
  case 3:
   {
    sort();
    rearrange_WF();
    break;
   }
  }
}
    return 1;
}
/*釋放ab數據結構節點*/
int dispose(struct allocated_block *free_ab){
    struct allocated_block *pre, *ab;
if(free_ab == allocated_block_head) { /*如果要釋放第一個節點*/
  allocated_block_head = allocated_block_head->next;
        free(free_ab);
        return 1;
}
else
{
  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;
}
}
/* 顯示當前內存的使用情況,包括空閑區的情況和已經分配的情況 */
display_mem_usage(){
    struct free_block_type *fbt=free_block;
    struct allocated_block *ab=allocated_block_head;
    if(fbt==NULL) return(-1);
    printf("----------------------------------------------------------\n");

    /* 顯示空閑區 */
    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;
}   
/* 顯示已分配區 */
    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;
}
do_exit()
{
printf("操作完畢,退出系統!\n");
}
main(){
    char choice;      pid=0;
    free_block = init_free_block(mem_size); //初始化空閑區
    while(1) {
  display_menu(); //顯示菜單
  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;
   } //創建新進程
        case '4':
   {
    kill_process();
    flag=1;  
    break;
   }  //刪除進程
        case '5':
   {
    display_mem_usage();   
    flag=1;
    break;
   }    //顯示內存使用
        case '0':
   {
    do_exit();
    exit(0);
   }//釋放鏈表並退出
        default: break;     
  }   
}
}
《解決方案》

沒看出來時簡單的。

[火星人 ] 一個簡單的內存管理程序已經有684次圍觀

http://coctec.com/docs/service/show-post-2587.html