process.c

这是一个操作系统中模拟内存管理的程序。主要展示内存的三种分配算法

//process.c  进程管理
//2007.12.12
extern int pid;
extern int ma_algorithm;
extern struct free_block_type* free_block;
extern struct allocated_area* allocated_block;
new_process()
{
    struct allocated_area *ab,*temp;
    int size;
    int ret;
    page_c();
    ab=(struct allocated_area*)malloc(sizeof(struct allocated_area));
    if(!ab) exit(-5);    //实际内存不足
    ab->next = NULL;
    pid++;
    ab->pid = pid;
    printf("请为%s%d进程分配内存:", "PROCESS ",pid);
    scanf("%d", &size);
    if(size>=MIN_SLICE)
    ab->size=size;
    else if(size>0)  ab->size=MIN_SLICE;
        else
        {
            printf("\n无效进程!\n\n任意键退出...");
            
        }
    ret = allocate_mem(ab);  /* 从空闲区分配内存，ret==1表示分配ok*/
    /*如果此时allocated_block尚未赋值，则赋值*/
    if((ret==1)&&(allocated_block == NULL))
        {
        allocated_block=ab;
        printf("创建成功！\n");
        printf("\n进程号 %d  内存空间 %d \n\n",ab->pid,ab->size);
        printf("任意键继续...");
        getch();
        return 1;
        }
    /*分配成功，将该已分配块的描述插入已分配链表*/
    else if (ret==1) {
        ab->next=NULL;
        temp=allocated_block;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=ab;
        printf("\n进程号 %d  内存空间 %d \n\n",ab->pid,ab->size);
        printf("任意键继续...");
        getch();
        return 2;
        }
    else if(ret==-1){ /*分配不成功*/
        printf("内存不足！\n\n任意键继续...");
        getch();
        free(ab);
        return -1;
        }
    return 3;
    }
/*分配内存模块*/
int allocate_mem(struct allocated_area *ab)
{
    struct free_block_type *fbt, *pre;
    int request=ab->size;
    fbt = pre = free_block;
    while(fbt!=NULL)
        {
            if(fbt->size>=request+MIN_SLICE)
            {
            /*分配后空闲空间足够大，则分割*/
              fbt->size=fbt->size-request;
              ab->start_addr=fbt->start_addr;
              fbt->start_addr=fbt->start_addr+request;
              return 1;                 	
             }
             else
             {
                /*分割后成小碎片，则一起分配*/
                if(fbt->size>=request)
                {
                ab->start_addr=fbt->start_addr;
                ab->size=fbt->size;
                if(pre=fbt)
                    free_block=free_block->next;
                else
                    pre->next=fbt->next;
                free(fbt);
                return 1;
                }
             }
             pre = fbt;
             fbt = fbt->next;
        }
    return -1;
}
/*删除进程，归还分配的存储空间，并删除描述该进程内存分配的节点*/
kill_process()
{
    struct allocated_area *ab,*temp;
    int l_pid;
    temp=allocated_block;
    page_c();
    printf("\n删除进程   pid=");
    scanf("%d", &l_pid);
    ab=NULL;
    while(temp!=NULL)
    {
        if(temp->pid==l_pid)
        {
            ab=temp;
            printf("pid  %d   size  %d",ab->pid,ab->size);
        }
        temp=temp->next;
    }
    if(ab!=NULL)
        {
            printf("\n已经找到该进程，正在删除...");
            free_mem(ab); /*释放ab所表示的分配区*/
            dispose(ab);  /*释放ab数据结构节点*/
            printf("\n该进程已经安全删除\n\n任意键继续...");
            getch();
            return 0;
        }
    else
        {
            printf("没有找到该进程!\n\n任意键继续...");
            getch();
            return 0;
        }
}

/*将ab所表示的分区归还，并进行可能的合并*/
int free_mem(struct allocated_area *ab)
    {
    int algorithm = ma_algorithm;
    struct free_block_type *fbt, *pre, *work;
    fbt=(struct free_block_type *)malloc(sizeof(struct free_block_type));
    fbt->size=ab->size;
    fbt->start_addr=ab->start_addr;
    /*插入到空闲区链表的头部并将空闲区按地址递增的次序排列*/
    fbt->next = free_block;
    free_block=fbt;
    rearrange(MA_FF);
    fbt=free_block;
    // 合并连续区域
    while(fbt!=NULL)
        {
            work = fbt->next;
            if(work!=NULL)
                {
                //如果当前空闲区与后面的空闲区相连，则合并两个分区
                if((fbt->start_addr+fbt->size)==work->start_addr)
                {
                    fbt->size=fbt->size+work->size;
                    fbt->next=work->next;
                    free(work);
                    continue;
                }
                }
        fbt = fbt->next;
        }
    rearrange(algorithm); /*重新按当前的算法排列空闲区*/
    return 1;
    }
/*释放ab数据结构节点*/
int dispose(struct allocated_area *free_ab)
{
    struct allocated_area *pre, *ab;

    if(free_ab == allocated_block)
    { /*如果要释放的节点是第一个节点*/
        allocated_block = allocated_block->next;
        free(free_ab);
        return 1;
    }
    pre = allocated_block;
    ab = allocated_block->next;
    while(ab!=free_ab)
    {
        pre = ab;
        ab = ab->next;
    }
    pre->next = ab->next;
    free(ab);
    return 2;
}