大学操作系统实验-优先级调度算法

最新推荐文章于 2024-05-03 10:14:52 发布

苦练算法的啊三

最新推荐文章于 2024-05-03 10:14:52 发布

阅读量131

点赞数 1

文章标签：算法单片机 stm32

本文链接：https://blog.csdn.net/m0_71883135/article/details/131449592

版权


#include<stdio.h>
#include<time.h>
#include<math.h>
#include<stdlib.h>
#include <windows.h>
#include<string.h>
 
typedef struct node
{
    char  name[10];    /*进程标识符*/
    int  prio;          /*进程优先数*/
    int  round;        /*进程时间片轮转时间片*/
    int  cputime;       /*进程占用CPU时间*/
    int  needtime;      /*进程到完成还需要的时间*/
    int  count;        /*进程执行计数器*/
    char  state;       /*进程的状态*/
    struct node *next;   /*链指针*/
}PCB;
 
enum Time{
    before = 1,
    after = 0
}Ti;
int T = 4; /*重新选择进程运行的周期(时间片)*/
PCB* RunQueue; /*运行队列*/
PCB* ReadyQueue; /*就绪队列*/
PCB* FinishQueue; /*完成队列*/
int ProcessCount; /*进程个数*/
int finishedCount = 0; /*已经完成的进程个数*/
const int LIMIT = 5000; /*用于计算优先权， Prio = LIMIT - needtime*/
int curTime = 0; /*运行周期次数*/
 
void initQueue();//初始化队列
void freeQueue();//释放队列内存
PCB* createProcess(char* name,int needtime);//创造进程控制快
void pushProcess(PCB *p,int prio);//根据优先级添加在队列里添加进程
void runProcess();//运行一次进程
void runProcessInRunQueue();//运行运行队列里面的进程
void printProcess(PCB *p);//打印进程信息
void printCurrentState(int Time);//打印进程运行之前的状态
void addToQueue(PCB *head ,PCB *p);//往对应的队列里面添加进程
void addToRunQueue(PCB *p);//往运行队列里添加进程
void addToReadyQueue(PCB *p);//往就绪队列里添加进程
void addToFinishQueue(PCB *p);//往完成队列里添加进程
void prioritySelect();//优先级搜索就绪队列添加进运训队列
void Priority();//优先级调度算法
void deleteProcess(PCB *head, PCB *p);//将进程从对应的队列里面删除
 
//初始化队列
void initQueue(){
    RunQueue = (PCB*)malloc(sizeof(PCB));
    RunQueue->next = NULL;
    ReadyQueue = (PCB*)malloc(sizeof(PCB));
    ReadyQueue->next = NULL;
    FinishQueue = (PCB*)malloc(sizeof(PCB));
    FinishQueue->next = NULL;
}
//释放队列内存
void freeQueue(){
    free(RunQueue);
    free(ReadyQueue);
    free(FinishQueue);
}
//将进程从队列里面删除
void deleteProcess(PCB* head,PCB *p){
    PCB *cur = head;
    while(cur->next != NULL){
        if(strcmp(cur->next->name,p->name) == 0){
            PCB *temp = cur->next;
            cur->next = temp->next;
            temp->next = NULL;
            break;
        }
        cur = cur->next;
    }
}
//创造进程控制快
PCB* createProcess(char* name,int needtime){
    PCB *p = (PCB*)malloc(sizeof(PCB));
    strcpy(p->name, name);
    p->prio =LIMIT-needtime; // 执行完一次后优先数减小
    p->cputime = 0;
    p->needtime = needtime;
    p->count = 0;
    p->state = 'r';
    p->next = NULL;
    ProcessCount++;
    return p;
}
//打印进程信息
void printProcess(PCB *p){
    printf("\tProcess: %s |prio: %d\t| cputime: %d\t| needtime: %d\t| state: %c\n",
        p->name, p->prio, p->cputime, p->needtime, p->state);
}
//打印进程运行状态
void printCurrentState(int Time){
//    system("cls");
    if(Time == before){
        printf("------------------------time %d before exexute---------------------------\n",
            curTime);
    }if(Time == after){
        printf("------------------------time %d after  exexute---------------------------\n",
            curTime);
    }
    puts("");
    puts("Running:");
    PCB *p = RunQueue;
    if(!p->next) puts("\tNone");
    while(p->next){
        printProcess(p->next);
        p = p->next;
    }
    puts("Ready:");
    p = ReadyQueue;
    if(!p->next) puts("\tNone");
    while(p->next){
        printProcess(p->next);
        p = p->next;
    }
    puts("Finish:");
    p = FinishQueue;
    if(!p->next) puts("\tNone");
    while(p->next){
        printProcess(p->next);
        p = p->next;
    }
    puts(" ");
}
//往队列里添加进程
void addToQueue(PCB *head ,PCB *p){
    PCB *cur = head;
    while(cur->next){
        cur = cur->next;
    }
    p->next = NULL;
    cur->next = p;
}
//往运行队列里添加进程
void addToRunQueue(PCB *p){
    p->state = 'E';
    addToQueue(RunQueue,p);
}
//往就绪队列里添加进程
void addToReadyQueue(PCB *p){
    p->state = 'R';
    addToQueue(ReadyQueue,p);
}
//往完成队列里添加进程
void addToFinishQueue(PCB *p){
    p->state = 'F';
    finishedCount++;
    addToQueue(FinishQueue,p);
}   
//运行一次时间片进程
void runProcess(PCB *p){
    if(p->needtime < T)    {
        p->cputime += p->needtime;
        p->needtime = 0;
    }
    else{
        p->cputime += T;
        p->needtime -= T;
    } 
    p->prio = p->prio - T;
    p->count++;
    if(p->needtime == 0) addToFinishQueue(p);
    else addToReadyQueue(p);
    deleteProcess(RunQueue,p);
}
//运行运行队列里面的进程
void runProcessInRunQueue(){
    PCB *p = RunQueue->next;
    while(p){
        runProcess(p);
        p = p->next;
    }
}
//优先级搜索就绪队列添加进运行队列
void prioritySelect(){
    PCB *re = ReadyQueue;
    PCB *maxPrio =(PCB*)malloc(sizeof(PCB));
    maxPrio = re->next;
    while(re->next){
        if(re->next->prio > maxPrio->prio){
            maxPrio = re->next;
        }
        re = re->next;
    }
    PCB *temp = maxPrio;
    deleteProcess(ReadyQueue,maxPrio);    
    addToRunQueue(maxPrio);
}
//优先级调度算法
void Priority(){
    printf("等待进程队列 :");
    //初始化队列
    initQueue();
    //创建进程
    PCB* p1 =  createProcess("p1", 5);
    PCB* p2 =  createProcess("p2", 8);
    PCB* p3 =  createProcess("p3", 12);
    PCB* p4 =  createProcess("p4", 7);
    PCB* p5 =  createProcess("p5", 9);
    PCB* p6 =  createProcess("p6", 4);
    addToReadyQueue(p1);
    addToReadyQueue(p2);
    addToReadyQueue(p3);
    addToReadyQueue(p4);
    addToReadyQueue(p5);
    addToReadyQueue(p6);
    printf("\n");
    printProcess(p1);
    printProcess(p2);
    printProcess(p3);
    printProcess(p4);
    printProcess(p5);
    printProcess(p6);
    while(ReadyQueue->next){
        //根据优先级搜队就绪队列加入到运行队列
        prioritySelect();
        printCurrentState(before);
        //运行运行队列里面的进程
        runProcessInRunQueue();
        printCurrentState(after);
        curTime++;
    }    
}
//伪主函数
int main(){
    Priority();
    return 0;