进程调度 时间片轮转算法

实验一进程调度

实验性质：设计

建议学时：6学时

实验目的：

通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统 性能的评价方法。

实验内容；

设计程序模拟进程的轮转法调度过程。假设初始状态为：有n个进程处于就绪状态，有m个进 程处于阻塞状态。釆用轮转法进程调度算法进行调度。调度过程中，假设处于执行状态的进程不会阻 塞，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。

程序要求如下：

1） 输出系统中进程的调度次序；

2） 计算CPU利用率。

实现提示：

用C语言实现提示：

1） 程序中进程可用PCB表示，其类型描述如下：

struct PCB_type {
char name ;	〃进程名
int state ;	//进程状态
2	表示“执行"状态
1——表示“就绪”状态
0——表示“阻塞”状态
int cpu_time ; 〃运行需要的CPU时间（需运行的时间片个数）
}

2） 设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的 进程PCB挂在队列blocked中。队列类型描述如下：

struct QueueNode{
struct PCB_type PCB;
Struct QueueNode *next;
}

并设全程量：

struct QueueNode ready_head=NULL, //ready队列队首指针
*ready_tail=NULL,    //ready队列队尾指针
*blocked_head=NULL,  //blocked队列队首指针
*blocked_tail=NULL;  //blocked队列队尾指针 
 

3）设计子程序

start_stateO； 〃读入假设的数据，设置系统初始状态
dispathO；	〃模拟调度
calculate。；	//计算 CPU 利用率

实验要求：

1） 上机前仔细编好程序；

2） 上机时独立调试程序；

3） 提交实验报告，包括纸质稿和电子稿两部分。实验报告要求详见实验报告模板。

测试用数据：

n=2 （处于就绪状态的进程的个数）

m=3 （处于阻塞状态的进程的个数）

t=5 （每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程）

测试用例：

代码展示

#include <iostream>
#include <fstream>
using namespace std;

struct PCB_type
{
    char name;
    /* 0:阻塞 1:就绪 2:执行 */
    int state;
    /* 需要的CPU时间，即运行的时间片个数 */
    double cpu_time;
};

struct QueueNode
{
    PCB_type PCB;
    QueueNode *next;
};

QueueNode *ready_head = NULL,
          *ready_tail = NULL,
          *blocked_head = NULL,
          *blocked_tail = NULL;

int all_time = 0;
int free_time = 0;
double time_slice_len = 1;

// 函数声明
void start_state();
void dispath();
void calculate();
void ready_Enqueue(QueueNode *p);
void blocked_Enqueue(QueueNode *p);
void ready_Dequeue();
void blocked_Dequeue();
QueueNode *ready_Front();
QueueNode *blocked_Front();

int main()
{
    start_state();
    dispath();
    calculate();
    system("pause");
    return 0;
}

void start_state()
{
    ifstream f;
    f.open("OS\\test1.txt");
    int ready_pcb_num, blocked_pcb_num;
    f >> ready_pcb_num;
    f >> blocked_pcb_num;
    // 就绪队列初始化
    for (int i = 0; i < ready_pcb_num; i++)
    {
        QueueNode *p = new QueueNode;
        f >> p->PCB.name >> p->PCB.cpu_time;
        p->PCB.state = 1;
        p->next = NULL;
        ready_Enqueue(p);
    }
    // 阻塞队列初始化
    for (int i = 0; i < blocked_pcb_num; i++)
    {
        QueueNode *p = new QueueNode;
        f >> p->PCB.name >> p->PCB.cpu_time;
        p->PCB.state = 0;
        p->next = NULL;
        blocked_Enqueue(p);
    }
    cout << "The processes in the ready queue are:" << endl;
    if (ready_head == NULL)
    {
        cout << "The ready queue is empty";
    }
    else
    {
        QueueNode *p = ready_head;
        while (p)
        {
            cout << p->PCB.name << " " << p->PCB.state << " " << p->PCB.cpu_time << endl;
            p = p->next;
        }
    }
    // 输入t
    int t;
    f >> t;
}

void dispath()
{
    cout << "Start scheduling" << endl;
    while (ready_head != NULL || blocked_head != NULL)
    {
        if (ready_head != NULL)
        {
            QueueNode *tmp = ready_Front();
            ready_Dequeue();
            tmp->PCB.state = 2;
            tmp->PCB.cpu_time -= time_slice_len;
            all_time++;
            printf("Time slice %d: process %c scheduling\n", all_time, tmp->PCB.name);
            if (tmp->PCB.cpu_time < time_slice_len)
            {
                printf("process %c over!\n", tmp->PCB.name);
            }
            else
            {
                ready_Enqueue(tmp);
            }
        }
        else
        {
            all_time++;
            free_time++;
            printf("Time slice %d: Free a slice of time\n", all_time);
        }
        if (blocked_head != NULL && all_time % 5 == 0)
        {
            QueueNode *tmp = blocked_Front();
            blocked_Dequeue();
            ready_Enqueue(tmp);
        }
    }
}

void calculate()
{
    cout << "CPU Utilization rate: " << ((all_time - free_time) / (double)all_time) * 100 << "%" << endl;
}

// 队列实现
void ready_Enqueue(QueueNode *p)
{
    if (ready_head == NULL)
    {
        ready_head = ready_tail = p;
    }
    else
    {
        ready_tail->next = p;
        ready_tail = p;
    }
}

void blocked_Enqueue(QueueNode *p)
{
    if (blocked_head == NULL)
    {
        blocked_head = blocked_tail = p;
    }
    else
    {
        blocked_tail->next = p;
        blocked_tail = p;
    }
}

void ready_Dequeue()
{
    QueueNode *temp = ready_head;
    if (ready_head == NULL)
    {
        printf("ready Queue is Empty\n");
        return;
    }
    if (ready_head == ready_tail)
    {
        ready_head = ready_tail = NULL;
    }
    else
    {
        ready_head = ready_head->next;
    }
}

void blocked_Dequeue()
{
    QueueNode *temp = blocked_head;
    if (blocked_head == NULL)
    {
        printf("blocked Queue is Empty\n");
        return;
    }
    if (blocked_head == blocked_tail)
    {
        blocked_head = blocked_tail = NULL;
    }
    else
    {
        blocked_head = blocked_head->next;
    }
}

QueueNode *ready_Front()
{
    return ready_head;
}

QueueNode *blocked_Front()
{
    return blocked_head;
}