进程调度模拟

操作系统原理进程调度模拟，基本思想：时间片轮转+优先级调度+可抢占，总是运行最高优先级进程(0~sizeof(int))

进程队列采用链表形式进行组织，进程数据结构如下：pro_id-->进程控制号，priority-->进程优先级，time_slice-->进程分配的时间片，*next-->指向下一进程

进程组织形式为单链表，没有采用双链表，在进行进程调度(就绪态提升到运行态)和唤醒进程(阻塞态转为就绪态)时进行了一下特殊处理：1、优先级调度，通过pcb_ready *getHighRdy(int *head_flag)返回最高优先级进程控制块指针，添加了一个head_flag标志位，返回最高优先级进程前一个进程控制块地址，便于操作，head_flag标志位用来标记是否为头结点进行处理；2、通过进程控制号pri_id唤醒进程，同理根据pcb_blocked *findWaitById(int id,int *head_flag)查找所对应id前一个进程控制块的地址

My OS Run a Pace 为运行一个系统时间片，运行一个系统时钟即系统滴答，若此时没有更高优先级的进程添加到就绪队列且当前运行进程的时间片没有运行完，就继续执行当前运行进程，否则从就绪队列中选择最高优先级的进程提升到运行态，支持可抢占式的

运行环境：codeblocks

整体代码如下：

#include <stdio.h>
#include <stdlib.h>

#define PACE 1  //系统滴答时钟

typedef struct pcb          //处于运行状态的进程
{
    int pro_id;     //进程控制号
    int priority;
    int time_slice; //时间片
    struct pcb *next;
}pcb;

typedef pcb pcb_running;
typedef pcb pcb_ready;
typedef pcb pcb_blocked;

pcb_running *pcb_run;
pcb_blocked *pcb_wait;
pcb_ready   *pcb_rdy;

int pid_no=1;                       //添加的进程id控制号

void pcb_init();
void print_menu();
void process_create();
void addProcessToRdy_Blocked(pcb *rdy_new,int flag);//0:添加pcb_rdy 1:添加pcb_wait
void runToBlocked();                //将当前运行进程挂起
void blockedToRdy();          //根据进程控制块中id号将阻塞进程唤醒
void swByPrio();                    //根据优先级进行进程调度
pcb_ready *getHighRdy(int *head_flag);               //优先级最高的进程控制块信息
pcb_blocked *findWaitById(int id,int *head_flag);         //根据id号找到要唤醒的阻塞进程
void printProcessInfo();
void do_exit();                    //释放进程占用内存块

int main()
{
    char choice;
    pcb_init();
    while(1){
        print_menu();
        choice=getchar();
        if(choice>='0'&&choice<='5'){
            switch(choice){
            case '1': process_create(); break;
            case '2': swByPrio();break;
            case '3': runToBlocked();break;
            case '4': blockedToRdy();break;
            case '5': printProcessInfo();break;
            case '0': do_exit(); exit(0);
            default: break;
            }
            getchar();      //读入enter键
        }
        else
            printf("
Please enter number 0~5:
");
    }

    return 0;
}
void pcb_init()
{
    pcb_run=NULL;
    pcb_wait=NULL;
    pcb_rdy=NULL;
}
void print_menu()
{
    printf("
");
    printf("1 - Create Process 
");
    printf("2 - My OS run a pace 
");
    printf("3 - Blocked the running process 
");
    printf("4 - Wakeup process by id 
");
    printf("5 - Display process info 
");
    printf("0 - Exit
");
}
void process_create()
{
    int priority,time_slice;
    pcb_ready *rdy_new;
    rdy_new=(pcb_ready*)malloc(sizeof(pcb_ready));
    if(rdy_new==NULL)
        exit(-1);

    printf("Please enter the priority、time_slice of the process
");
    scanf("%d%d",&priority,&time_slice);

    rdy_new->pro_id=pid_no++;
    rdy_new->priority=priority;
    rdy_new->time_slice=time_slice;
    rdy_new->next=NULL;

    addProcessToRdy_Blocked(rdy_new,0);
}
void addProcessToRdy_Blocked(pcb *rdy_new,int flag)
{
    if(flag){
        if(pcb_wait==NULL) //就绪进程队列为空
            pcb_wait=rdy_new;
        else{             //将添加进来的进程直接添加到队首
            rdy_new->next=pcb_wait->next;
            pcb_wait->next=rdy_new;
        }
    }
    else{
        if(pcb_rdy==NULL) //就绪进程队列为空
            pcb_rdy=rdy_new;
        else{             //将添加进来的进程直接添加到队首
            rdy_new->next=pcb_rdy->next;
            pcb_rdy->next=rdy_new;
        }
    }
}
void runToBlocked()
{
    addProcessToRdy_Blocked(pcb_run,1);
    pcb_run=NULL;
}
pcb_blocked *findWaitById(int id,int *head_flag)
{
    pcb_blocked *wait,*w;
    if(pcb_wait==NULL)
        wait=NULL;
    else if(pcb_wait->pro_id==id){
         wait=pcb_wait;
         *head_flag=1;
    }
    else{
        w=pcb_wait;
        while(w->next){
            if(w->next->pro_id==id){
                wait=w;
                *head_flag=0;
                break;
            }
            w=w->next;
        }
    }
    return wait;
}
void blockedToRdy()
{
    pcb_blocked *blocked;
    int process_id,head_flag=0;
    printf("Please enter the ready process id that you want to wakeup 
");
    scanf("%d",&process_id);
    blocked=findWaitById(process_id,&head_flag);         //返回id的头一个结点
    if(blocked==NULL){              //没有找到对应id的阻塞进程
        printf("The blocked process id is wrong 
");
    }
    else if(head_flag)             //头结点
        pcb_wait=pcb_wait->next;
    else                           //blocked指向唤醒进程前一个进程地址
        blocked->next=blocked->next->next;

    addProcessToRdy_Blocked(blocked,0);

}
pcb_ready *getHighRdy(int *head_flag)
{
    pcb_ready *rdy,*r;
    if(pcb_rdy==NULL)
        rdy=NULL;
    else{
        r=rdy=pcb_rdy;
        *head_flag=1;
        while(r->next){
            if(rdy->priority>=r->next->priority){
                rdy=r;              //返回最高优先级控制块前一个进程控制块
                *head_flag=0;
            }
            r=r->next;
        }
    }
    //printf("%d
",rdy->pro_id);
    if(pcb_run!=NULL&&rdy!=NULL){
        if(rdy->next->priority>=pcb_run->priority)//就绪队列中最高优先级的进程小于运行进程的优先级
            rdy=NULL;
    }
    return rdy;
}
void swByPrio()
{
    pcb_ready *rdy,*pcb_temp;
    int head_flag=0;
    if(pcb_run!=NULL){
        pcb_run->time_slice-=PACE;
        if(pcb_run->time_slice<=0){
            free(pcb_run);
            pcb_run=NULL;
            printf("The process has already finished 
");
        }
    }

    rdy=getHighRdy(&head_flag);
    if(rdy==NULL)
        printf("the running priority is highest or ready queue is null
");
    else if(head_flag){                 //运行的进程为就绪队列头结点
        pcb_temp=pcb_run;
        pcb_run=rdy;
        pcb_rdy=pcb_rdy->next;

        pcb_run->next=NULL;

        if(pcb_temp!=NULL)
            addProcessToRdy_Blocked(pcb_temp,0);       //将运行进程添加到就绪队列
    }
    else {                              //运行的进程非头结点
        pcb_temp=pcb_run;
        pcb_run=rdy->next;
        rdy->next=rdy->next->next;      //在就绪队列中删除转为运行的进程

        pcb_run->next=NULL;
        if(pcb_temp!=NULL)
            addProcessToRdy_Blocked(pcb_temp,0);       //将运行进程添加到就绪队列
    }
}
void printProcessInfo()
{
    pcb_ready *rdy;
    pcb_blocked *wait;

    printf("run process:
");
    if(pcb_run)
        printf("id:%2d	priority:%2d	time_slice:%2d
",pcb_run->pro_id,pcb_run->priority,pcb_run->time_slice);
    else
        printf("the run queue is null
");

    rdy=pcb_rdy;
    printf("Ready process:
");
    if(rdy){
        while(rdy){
        printf("id:%2d	priority:%2d	time_slice:%2d
",rdy->pro_id,rdy->priority,rdy->time_slice);
        rdy=rdy->next;
        }
    }
    else
        printf("the ready queue is null
");

    wait=pcb_wait;
    printf("wait process:
");
    if(wait!=NULL){
        while(wait){
        printf("id:%2d	priority:%2d	time_slice:%2d
",wait->pro_id,wait->priority,wait->time_slice);
        wait=wait->next;
        }
    }
    else
        printf("the wait queue is null
");
}
void do_exit()
{
    pcb *pcb_next;
    if(pcb_run!=NULL)
        free(pcb_run);

    if(pcb_rdy!=NULL){
        while(pcb_rdy){
            pcb_next=pcb_rdy->next;
            free(pcb_rdy);
            pcb_rdy=pcb_next;
        }
    }

    if(pcb_wait!=NULL){
        while(pcb_wait){
            pcb_next=pcb_wait->next;
            free(pcb_wait);
            pcb_wait=pcb_next;
        }
    }
}