操作系统实验报告16：CPU 调度

最新推荐文章于 2024-01-27 15:56:11 发布
最新推荐文章于 2024-01-27 15:56:11 发布
阅读量1k 收藏 13
点赞数
分类专栏： 操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/StuGeek/article/details/118708878
版权

操作系统实验报告16

实验内容

  • 实验内容：CPU 调度。
    • 讨论课件 Lecture19-20 中 CPU 调度算法的例子，尝试基于 POSIX API 设计一个简单调度器（不考虑资源竞争问题）：
      • 创建一些 Pthread 线程任务，建立一个管理链队列，结点内容起码包括到达时间、WCT、优先级、调度状态（运行、就绪、阻塞）等调度参数；
      • 每个任务有一个调度信号量，任务启动后在其调度信号量上执行 wait；
      • 调度器按照调度策略对处于运行态的任务（如果有的话）的调度信号量执行 wait，并选取适当任务的调度信号量执行 signal；
      • 实现简单调度策略：FCFS、SJF、Priority。分别计算任务平均等待时间。
    • 拓展问题1：设计若干资源信号量模拟资源竞争情况；增加时间片参数实现 RR 调度；验证优先级反转；建立多个链队列实现多级反馈调度。
    • 拓展问题2：设计一个抢占式优先策略实时调度器，测试在一个给定的工作负载下优先级反转的情况。

实验环境

  • 架构：Intel x86_64 (虚拟机)
  • 操作系统：Ubuntu 20.04
  • 汇编器：gas (GNU Assembler) in AT&T mode
  • 编译器：gcc

技术日志

实验内容原理

  • CPU调度程序
    • 每当CPU空闲时，操作系统就应从就绪队列中选择一个进程来执行。进程执行选择短期调度程序或CPU调度程序。调度程序从内存中选择一个能够执行的进程，并为其分配CPU。
    • 注意,就绪队列不必是先进先出队列。就绪队列的实现可以是FIFO队列、优先队列、树或简单的无序链表等。然而，在概念上，就绪队列内的所有进程都要排队以便等待在CPU上运行。队列内的记录通常为进程控制块（PCB）。
  • 抢占调度
    • 需进行CPU调度的情况可分为以下四种：
      • 当一个进程从运行状态切换到等待状态时（例如，I/O请求，或wait()调用以便等待一个子进程的终止）。
      • 当一个进程从运行状态切换到就绪状态时（例如，当出现中断时）。
      • 当一个进程从等待状态切换到就绪状态时（例如，I/O完成）。
      • 当一个进程终止时。
    • 对于第1种和第4种情况，除了调度没有选择。一个新进程（如果就绪队列有一个进程存在）必须被选择执行。不过，对于第2种和第3种情况，还是有选择的。
    • 如果调度只能发生在第1种和第4种情况下，则调度方案称为非抢占的或协作的；否则，调度方案称为抢占的。
      • 在非抢占调度下，一旦某个进程分配到CPU，该进程就会一直使用CPU，直到它终止或切换到等待状态。
    • 当多个进程共享数据时，抢占调度可能导致竞争情况。
  • 调度算法
    • 先到先服务（FCFS）调度
      • 是非抢占式算法
      • 采用这种方案，先请求CPU的进程首先分配到CPU。
      • FCFS策略可以通过FIFO队列容易地实现。当一个进程进入就绪队列时，它的PCB会被链接到队列尾部。当CPU空闲时，它会分配给位于队列头部的进程，并且这个运行进程从队列中移去。
      • FCFS调度代码编写简单并且理解容易。缺点是，平均等待时间往往很长。
      • 护航效果：所有其他进程都等待一个大进程释放CPU。与让较短进程先进行相比，这会导致CPU和设备的使用率降低。
    • 最短作业优先（SJF）调度
      • 有非抢占式也有抢占式算法
      • 这个算法将每个进程与其下次CPU执行的长度关联起来。当CPU变为空闲时，它会被赋给具有最短CPU执行的进程。如果两个进程具有同样长度的CPU执行，那么可以由FCFS来处理。
      • 注意，一个更为恰当的表示是最短下次CPU执行算法，这是因为调度取决于进程的下次CPU执行的长度，而不是其总的长度。
      • 当一个新进程到达就绪队列而以前进程正在执行时，就需要选择使用非抢占式算法还是抢占式算法了。新进程的下次CPU执行，与当前运行进程的尚未完成的CPU执行相比，可能还要小。
        • 抢占SJF算法会抢占当前运行进程。
        • 非抢占SJF算法会允许当前运行进程以先完成CPU执行。
      • 抢占SJF调度有时称为最短剩余时间优先调度
    • 优先级调度（Priority）
      • 有非抢占式也有抢占式算法
      • 每个进程都有优先级与其关联，而具有最高优先级的进程会分配到CPU。具有相同优先级的进程按FCFS顺序调度。
      • 当一个进程到达就绪队列时，比较它的优先级与当前运行进程的优先级。如果新到达进程的优先级高于当前运行进程的优先级，那么抢占优先级调度算法就会抢占CPU。非抢占式优先级调度算法只是将新的进程加到就绪队列的头部。
      • 优先级调度算法的一个主要问题是无穷阻塞或饥饿。就绪运行但是等待CPU的进程可以认为是阻塞的。优先级调度算法可让某个低优先级进程无穷等待CPU。
      • 低优先级进程的无穷等待问题的解决方案之一是老化。老化逐渐增加在系统中等待很长时间的进程的优先级。

设计报告

调度器设计图

代码设计
// scheduler.c文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>

#define STATUS_RUNNING 1  // 运行调度状态
#define STATUS_READY 2    // 就绪调度状态
#define STATUS_WAITING 3  // 阻塞调度状态

#define POLICY_FCFS 1             // 先到先服务调度策略
#define POLICY_SJF_PEM 2          // 抢占式最短作业优先调度策略
#define POLICY_SJF_NOT_PEM 3      // 非抢占式最短作业优先调度策略
#define POLICY_PRIORITY_PEM 4     // 抢占式优先级调度策略
#define POLICY_PRIORITY_NOT_PEM 5 // 非抢占式优先级调度策略

#define MAX_TASK_NUM 100 // 最大任务个数

typedef struct node {
    int arrival_time;     // 到达时间
    int WCT;              // 最坏预期执行时间
    int priority;         // 优先级
    int schedule_status;  // 调度状态
    pthread_t ptid;       // 线程号
    sem_t wait_sem;       // 任务启动时的调度等待信号量
    struct node *next;    // 指向下一个结点的指针
} Tasknode; // 管理链队列结点结构

typedef struct {
    Tasknode *head;               // 管理链队列表头
    pthread_t sched_ptid;         // 调度器线程的线程号
    pthread_mutex_t sched_mutex;  // 调度器互斥锁
    int schedule_policy;          // 调度策略
    int finished_task;            // 完成任务的个数
} Scheduler; // 调度器结构

Scheduler sched; // 调度器
sigset_t zeromask; // 阻塞线程函数sigsuspend()所用参数
long wait_sum_time = 0; // 单个线程等待总时间

long begin_us, run_us; // 总计时器部分，测试用
struct timeval t_time;

// 初始化调度器
void init_scheduler(int task_num);
// 创建任务管理信息结点
Tasknode* creat_thread_node(int arrival_time, int WCT, int priority);

// 每个线程执行的任务
void *task_runner(void *arg);
// 调度器运行线程
void *schedule_runner(void *arg);

// 将任务信息结点按照调度策略放入管理链队列
void fcfs(Tasknode *new_node);
void sjf_pem(Tasknode *new_node);
void sjf_not_pem(Tasknode *new_node);
void priority_pem(Tasknode *new_node);
void priority_not_pem(Tasknode *new_node);

// 向管理链队列添加任务
void add_task(Tasknode *node, int sched_policy);
// 从管理链队列删除任务
void delete_task();

// 发送信号阻塞线程，直到接收到一个新的信号
void thread_wait_sighand(int signo);
// 发送信号使阻塞线程继续运行
void thread_cont_sighand(int signo);
// 调度器线程接收信号后调度器选择一个任务，即表头任务运行
void sched_run_sighand(int signo);

// 打印任务信息列表，测试用
void print_tasklist(int *arrival_time, int *WCT, int *priority, int task_num);
// 计算任务平均等待时间
double cal_aver_wait_time(int *arrival_time, int *WCT, int *priority, int task_num, int sched_policy);

// 调度器运行线程
void *schedule_runner(void *arg) {
    int task_num = *(int *)arg;
    // 当完成任务个数等于总任务个数时，调度器线程退出
    while (sched.finished_task != 5 * task_num);
    pthread_exit(0);
}

// 创建任务管理信息结点
Tasknode* creat_thread_node(int arrival_time, int WCT, int priority) {
    Tasknode *new_node = (Tasknode *)malloc(sizeof(Tasknode));
    // 设置线程的到达时间，最长预期执行时间，优先级
    new_node->arrival_time = arrival_time;
    new_node->WCT = WCT;
    new_node->priority = priority;
    new_node->next = NULL;
    // 初始化线程的调度等待信号量为0
    int ret = sem_init(&new_node->wait_sem, 1, 0);
    if (ret == -1) {
        perror("creat_thread_node(): sem_init-wait_sem");
        exit(1);
    }
    return new_node;
}

// 初始化调度器
void init_scheduler(int task_num) {
    // 管理链队列的表头为空
    sched.head = NULL;
    // 调度策略默认为先到先服务
    sched.schedule_policy = POLICY_FCFS;
    // 已经完成任务个数为0
    sched.finished_task = 0;
    // 初始化调度器互斥锁
    pthread_mutex_init(&sched.sched_mutex, NULL);
    // 创建调度器运行线程
    int ret = pthread_create(&sched.sched_ptid, NULL, &schedule_runner, &task_num);
    if (ret != 0) {
        fprintf(stderr, "init_scheduler(): pthread_create error: %s\n", strerror(ret));
        exit(1);
    }
}

// 将任务信息结点按照先到先服务策略放入管理链队列
void fcfs(Tasknode *new_node) {
    // 如果管理链队列的表头为空，那么直接插入结点
    if (sched.head == NULL) {
        sched.head = new_node;
        return;
    }

    // 找到管理链队列的表尾，插入结点
    Tasknode *cur_node = sched.head;
    while (cur_node->next != NULL) {
        cur_node = cur_node->next;
    }
    cur_node->next = new_node;
}

// 将任务信息结点按照抢占式最短作业优先策略放入管理链队列
void sjf_pem(Tasknode *new_node) {
    // 如果管理链队列的表头为空，那么直接插入结点
    if (sched.head == NULL) {
        sched.head = new_node;
        return;
    }
    // 如果结点的WCT小于表头结点的WCT，那么直接在表头结点之前插入结点
    else if (new_node->WCT < sched.head->WCT) {
        new_node->next = sched.head;
        sched.head = new_node;
        return;
    }

    Tasknode *cur_node = sched.head;
    Tasknode *pre_node = NULL;
    
    while (cur_node != NULL && new_node->WCT >= cur_node->WCT) {
        pre_node = cur_node;
        cur_node = cur_node->next;
    }
    pre_node->next = new_node;
    new_node->next = cur_node;
}

// 将任务信息结点按照非抢占式最短作业优先策略放入管理链队列
void sjf_not_pem(Tasknode *new_node) {
    // 如果管理链队列的表头为空，那么直接插入结点
    if (sched.head == NULL) {
        sched.head = new_node;
        return;
    }

    // 寻找管理链队列中前一个结点的WCT小于等于结点，后一个结点的WCT大于结点的位置插入结点，如果没有那么就在表尾插入结点
    Tasknode *cur_node = sched.head->next;
    Tasknode *pre_node = sched.head;
    while (cur_node != NULL && new_node->WCT >= cur_node->WCT) {
        pre_node = cur_node;
        cur_node = cur_node->next;
    }
    pre_node->next = new_node;
    new_node->next = cur_node;
}

// 将任务信息结点按照抢占式优先级策略放入管理链队列
void priority_pem(Tasknode *new_node) {
    // 如果管理链队列的表头为空，那么直接插入结点
    if (sched.head == NULL) {
        sched.head = new_node;
        return;
    }
    // 如果结点的优先级大于表头结点的优先级，那么直接在表头结点之前插入结点
    else if (new_node->priority > sched.head->priority) {
        new_node->next = sched.head;
        sched.head = new_node;
        return;
    }

    // 寻找管理链队列中前一个结点的WCT小于等于结点，后一个结点的WCT大于结点的位置插入结点，如果没有那么就在表尾插入结点
    Tasknode *cur_node = sched.head;
    Tasknode *pre_node = NULL;
    while (cur_node != NULL && new_node->priority <= cur_node->priority) {
        pre_node = cur_node;
        cur_node = cur_node->next;
    }
    pre_node->next = new_node;
    new_node->next = cur_node;
}

// 将任务信息结点按照非抢占式优先级策略放入管理链队列
void priority_not_pem(Tasknode *new_node) {
    // 如果管理链队列的表头为空，那么直接插入结点
    if (sched.head == NULL) {
        sched.head = new_node;
        return;
    }

    // 寻找管理链队列中前一个结点的优先级大于等于结点，后一个结点的优先级小于结点的位置插入结点，如果没有那么就在表尾插入结点
    Tasknode *cur_node = sched.head->next;
    Tasknode *pre_node = sched.head;
    while (cur_node != NULL && new_node->priority <= cur_node->priority) {
        pre_node = cur_node;
        cur_node = cur_node->next;
    }
    pre_node->next = new_node;
    new_node->next = cur_node;
}

// 向管理链队列添加任务
void add_task(Tasknode *node, int sched_policy) {
    // 获取调度器的互斥锁，防止其它线程更改调度器
    pthread_mutex_lock(&sched.sched_mutex);
    // 如果有任务正在运行，那么先阻塞这个任务，将这个任务的调度状态改为就绪态
    if (sched.head != NULL) {
        pthread_kill(sched.head->ptid, SIGUSR1);
        sched.head->schedule_status = STATUS_READY;
    }
    // 添加的任务信息结点的调度状态为阻塞态
    node->schedule_status = STATUS_WAITING;

    // 根据调度策略，向管理链队列中插入任务信息结点
    switch (sched_policy) {
        case POLICY_FCFS :
            fcfs(node);
            break;
        case POLICY_SJF_PEM:
            sjf_pem(node);
            break;
        case POLICY_SJF_NOT_PEM:
            sjf_not_pem(node);
            break;
        case POLICY_PRIORITY_PEM:
            priority_pem(node);
            break;
        case POLICY_PRIORITY_NOT_PEM:
            priority_not_pem(node);
            break;
    }
    sleep(0);
    // 向调度器线程发送信号，选取适当的任务执行
    pthread_kill(sched.sched_ptid, SIGUSR2);

    // 释放调度器的互斥锁
    pthread_mutex_unlock(&sched.sched_mutex);
}

// 从管理链队列删除任务
void delete_task() {
    // 获取调度器的互斥锁，防止其它线程更改调度器
    pthread_mutex_lock(&sched.sched_mutex);

    // 运行完了的任务结点是管理链队列的头结点，释放其资源
    Tasknode *temp = sched.head;
    sched.head = sched.head->next;
    sem_destroy(&temp->wait_sem);
    free(temp);
    temp = NULL;
    // 如果管理链队列中还有任务，那么继续运行
    if (sched.head != NULL) {
        pthread_kill(sched.head->ptid, SIGCONT);
    }

    // 释放调度器的互斥锁
    pthread_mutex_unlock(&sched.sched_mutex);
}

// 每个线程执行的任务
void *task_runner(void *arg) {
    int ret;
    // 计时器部分
    long start_us, end_us;
    struct timeval t;

    // 获取每个线程的任务信息结点
    Tasknode *task_node = (Tasknode *)arg;
    struct timespec req, rem;
    // 设置这个任务信息结点的线程号
    task_node->ptid = pthread_self();
    // 设置线程运行时间为任务信息结点中的最长预期执行时间
    req.tv_sec = task_node->WCT;
    req.tv_nsec = 0;

    // 线程休眠任务信息结点中的到达时间后再加入管理链队列，模拟到达时间
    sleep(task_node->arrival_time);
    // 获取任务到达时间
    gettimeofday(&t, 0);
    start_us = (long)(t.tv_sec * 1000 * 1000) + t.tv_usec;
    add_task(task_node, sched.schedule_policy);

    // 获取任务开始时间
    gettimeofday(&t_time, 0);
    run_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
    // 打印这个执行任务的线程的开始任务时间点，测试用
    printf("Task ptid = %ld starts at Time: %lf sec\n", pthread_self(), (double)(run_us - begin_us) / 1000000.0);
    // 线程先阻塞，等待调度器调度
    sem_wait(&task_node->wait_sem);
    
    // 线程休眠时间模拟执行时间，如果有信号中断，ret返回-1，剩余时间存储rem中
    ret = nanosleep(&req, &rem);
    // 返回中断后继续休眠剩余时间模拟完整执行时间
    while (ret < 0) {
        req = rem;
        ret = nanosleep(&req, &rem);
    }

    // 获取结束时间
    gettimeofday(&t, 0);
    end_us = (long)(t.tv_sec * 1000 * 1000) + t.tv_usec;
    // 打印任务结束时间
    gettimeofday(&t_time, 0);
    run_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
    // 打印这个执行任务的线程的结束任务时间点，测试用
    printf("Task ptid = %ld ends at Time: %lf sec\n", pthread_self(), (double)(run_us - begin_us) / 1000000.0);
    // 等待时间为实际运行时间减去预期执行时间
    wait_sum_time += end_us - start_us - task_node->WCT * 1000 * 1000;
    // 执行完后从管理链队列中删除任务结点
    delete_task();
    // 调度器已完成的任务数加一
    sched.finished_task++;
    
    pthread_exit(0);
}

// 发送信号阻塞线程，直到接收到一个新的信号
void thread_wait_sighand(int signo) {
    // 获取当前时间
    gettimeofday(&t_time, 0);
    run_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
    // 打印这个执行任务的线程的阻塞时间点，测试用
    printf("Task ptid = %ld stops at Time: %lf sec\n", pthread_self(), (double)(run_us - begin_us) / 1000000.0);
    sigsuspend(&zeromask);
}

// 发送信号使阻塞线程继续运行
void thread_cont_sighand(int signo) {
    // 获取当前时间
    gettimeofday(&t_time, 0);
    run_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
    // 打印这个执行任务的线程的阻塞之后继续运行时间点，测试用
    printf("Task ptid = %ld continues at Time: %lf sec\n", pthread_self(), (double)(run_us - begin_us) / 1000000.0);
}

// 调度器线程接收信号后调度器选择一个任务，即表头任务运行
void sched_run_sighand(int signo) {
    // 如果这个任务处于阻塞态，那么先转为就绪态，再转为运行态，用sem_post()函数开始运行任务
    if (sched.head->schedule_status == STATUS_WAITING) {
        sched.head->schedule_status = STATUS_READY;
        sched.head->schedule_status = STATUS_RUNNING;
        sem_post(&sched.head->wait_sem);
        // 获取任务执行时间点 
        gettimeofday(&t_time, 0);
        run_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
        // 打印这个执行任务的线程的运行任务时间点，测试用
        printf("Task ptid = %ld starts to run at Time: %lf sec\n", sched.head->ptid, (double)(run_us - begin_us) / 1000000.0);
    }
    // 如果这个任务处于就绪态，那么转为运行态，发送信号使其继续运行
    else if (sched.head->schedule_status == STATUS_READY) {
        sched.head->schedule_status = STATUS_RUNNING;
        pthread_kill(sched.head->ptid, SIGCONT);
    }
}

// 打印任务信息列表，测试用
void print_tasklist(int *arrival_time, int *WCT, int *priority, int task_num) {
    printf("Task list:\n");
    printf("------------------------------\n");
    printf("|Id|Arrival time|WCT|Priority|\n");
    printf("------------------------------\n");
    for (int i = 0; i < task_num; ++i) {
        printf("|%2d|    %3d     |%3d|   %2d   |\n", i + 1, arrival_time[i], WCT[i], priority[i]);
    }
    printf("------------------------------\n");
    printf("\n");
}

// 计算任务平均等待时间
double cal_aver_wait_time(int *arrival_time, int *WCT, int *priority, int task_num, int sched_policy) {
    int ret;
    pthread_t ptid[MAX_TASK_NUM];
    double aver_wait_time;
    printf("\n----------------------------------------------------------\n");
    printf("schedule policy: ");
    // 打印调度策略
    switch (sched_policy) {
        case POLICY_FCFS :
            printf("FCFS\n\n");
            break;
        case POLICY_SJF_PEM:
            printf("SJF(preemptive)\n\n");
            break;
        case POLICY_SJF_NOT_PEM:
            printf("SJF(not preemptive)\n\n");
            break;
        case POLICY_PRIORITY_PEM:
            printf("Priority(preemptive)\n\n");
            break;
        case POLICY_PRIORITY_NOT_PEM:
            printf("Priority(not preemptive)\n\n");
            break;
    }
    // 打印任务列表
    print_tasklist(arrival_time, WCT, priority, task_num);
    // 设置调度策略
    sched.schedule_policy = sched_policy;
    wait_sum_time = 0;
    // 获取计时开始时间
    gettimeofday(&t_time, 0);
    begin_us = (long)(t_time.tv_sec * 1000 * 1000) + t_time.tv_usec;
    // 根据信息创建任务信息结点和相应的线程
    for (int i = 0; i < task_num; i++) {
        Tasknode *new_node = creat_thread_node(arrival_time[i], WCT[i], priority[i]);
        ret = pthread_create(&ptid[i], NULL, &task_runner, (void *)new_node);
        if(ret != 0) {
            fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
            exit(1);
        }
        printf("Task%d ptid:%ld\n", i + 1, ptid[i]);
    }
    printf("\n");
    // 主线程等待所有子线程运行结束后再继续执行
    for (int i = 0; i < task_num; i++) {
        ret = pthread_join(ptid[i], NULL);
        if(ret != 0) {
            fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
            exit(1);
        }
    }
    // 计算任务平均等待时间
    printf("\nThe waiting time = %lf sec\n", (double)wait_sum_time / 1000000.0);
    aver_wait_time = (double)wait_sum_time / 1000000.0 / (double)task_num;
    printf("The average of waiting time = %lf sec\n", aver_wait_time);
    printf("----------------------------------------------------------\n");

    return aver_wait_time;
}

int main() {
    int arrival_time[MAX_TASK_NUM];
    int WCT[MAX_TASK_NUM];
    int priority[MAX_TASK_NUM];

    int task_num;
    printf("Please input the number of tasks: ");
    scanf("%d", &task_num);

    // 设置不同捕捉信号的信号处理函数
    struct sigaction act1, act2, act3;
    memset(&act1, 0, sizeof(act1));
    memset(&act2, 0, sizeof(act2));
    memset(&act3, 0, sizeof(act3));
    sigemptyset(&act1.sa_mask);
    sigemptyset(&act2.sa_mask);
    sigemptyset(&act3.sa_mask);
    act1.sa_flags = 0;
    act2.sa_flags = 0;
    act3.sa_flags = 0;
    act1.sa_handler = thread_wait_sighand;
    act2.sa_handler = thread_cont_sighand;
    act3.sa_handler = sched_run_sighand;
    // 设置捕捉到SIGUSR1后信号处理函数为使线程阻塞
    sigaction(SIGUSR1, &act1, NULL);
    // 设置捕捉到SIGCONT后信号处理函数为使阻塞的线程继续
    sigaction(SIGCONT, &act2, NULL);
    // 设置捕捉到SIGUSR2后信号处理函数为使调度器选择一个任务运行
    sigaction(SIGUSR2, &act3, NULL);

    // 初始化调度器
    init_scheduler(task_num);

    // 输入每个任务的到达时间，最长预期运行时间，优先级等
    for (int i = 0; i < task_num; i++) {
        printf("Please input task%d's arrival_time, WCT, priority:\n", i + 1);
        scanf("%d %d %d", &arrival_time[i], &WCT[i], &priority[i]);
    }

    double aver_wait_time_fcfs = cal_aver_wait_time(arrival_time, WCT, priority, task_num, POLICY_FCFS);
    double aver_wait_time_sjf_pem = cal_aver_wait_time(arrival_time, WCT, priority, task_num, POLICY_SJF_PEM);
    double aver_wait_time_sjf_not_pem = cal_aver_wait_time(arrival_time, WCT, priority, task_num, POLICY_SJF_NOT_PEM);
    double aver_wait_time_priority_pem = cal_aver_wait_time(arrival_time, WCT, priority, task_num, POLICY_PRIORITY_PEM);
    double aver_wait_time_priority_not_pem = cal_aver_wait_time(arrival_time, WCT, priority, task_num, POLICY_PRIORITY_NOT_PEM);

    // 打印不同调度策略平均等待时间列表
    printf("\nAverage waiting time list(sec):\n");
    printf("-----------------------------------------------\n");
    printf("|         Policy         |Average waiting time|\n");
    printf("-----------------------------------------------\n");
    printf("|          FCFS          |     %10lf     |\n", aver_wait_time_fcfs);
    printf("|     SJF(preemptive)    |     %10lf     |\n", aver_wait_time_sjf_pem);
    printf("|   SJF(not preemptive)  |     %10lf     |\n", aver_wait_time_sjf_not_pem);
    printf("|  Priority(preemptive)  |     %10lf     |\n", aver_wait_time_priority_pem);
    printf("|Priority(not preemptive)|     %10lf     |\n", aver_wait_time_priority_not_pem);
    printf("-----------------------------------------------\n");
}

执行命令：

gcc scheduler.c -pthread
./a.out
验证各个调度算法的正确性

测试用例1：

3
0 5 1
2 4 3
4 3 2
TaskArrival TimeWCTPriority
1051
2243
3432

先到先服务调度策略：

可以看到，任务1在0s时开始执行；
在2s时任务2到达，运行着的任务1先阻塞，加入任务2后调度器根据先到先服务策略继续选择任务1执行，任务1在2s时继续执行，任务2阻塞；
在4s时任务3到达，运行着的任务1先阻塞，加入任务3后调度器根据先到先服务策略继续选择任务1执行，任务1在4s时继续执行，任务3阻塞；
在5s时任务1结束，调度器根据先到先服务策略选择任务2执行，任务2在5s继续执行；
在9s时任务2结束，调度器根据先到先服务策略选择任务3执行，任务2在9s继续执行；
在12s时任务3结束，任务全部完成。

过程符合先到先服务的调度策略。

甘特图：

计算等待时间为 (0 - 0) + (5 - 2) + (9 - 4) = 8
计算平均等待时间为 8 / 3 = 2.67s
计算也正确。

抢占式最短作业优先调度策略：

可以看到，任务1在0s时开始执行；
在2s时任务2到达，运行着的任务1先阻塞，加入任务2后，由于任务2的WCT比任务1小，所以调度器根据抢占式最短作业优先调度策略，选择任务2执行，任务2在2s时开始执行，任务1阻塞；
在4s时任务3到达，运行着的任务2先阻塞，加入任务3后，由于任务3的WCT比任务2小，所以调度器根据抢占式最短作业优先调度策略选择任务3执行，任务3在4s时开始执行，任务2阻塞；
在7s时任务3结束，调度器根据抢占式最短作业优先调度策略选择任务2执行，任务2在7s继续执行；
在9s时任务2结束，调度器根据抢占式最短作业优先调度策略选择任务1执行，任务1在9s继续执行；
在12s时任务3结束，任务全部完成。

过程符合抢占式最短作业优先的调度策略。

甘特图：

计算等待时间为 (9 - 2) + (7 - 4) + (4 - 4) = 10
计算平均等待时间为 10 / 3 = 3.33s
计算也正确。

非抢占式最短作业优先调度策略：

可以看到，任务1在0s时开始执行；
在2s时任务2到达，运行着的任务1先阻塞，加入任务2后，虽然任务2的WCT比任务1小，但是调度器根据非抢占式最短作业优先调度策略，继续选择任务1执行，任务1在2s时继续执行，任务2阻塞；
在4s时任务3到达，运行着的任务1先阻塞，加入任务3后，虽然任务3的WCT比任务1小，但是调度器根据非抢占式最短作业优先调度策略继续选择任务1执行，任务1在4s时继续执行，任务3阻塞；
在5s时任务1结束，调度器根据非抢占式最短作业优先调度策略选择WCT更小的任务3执行，任务3在5s继续执行；
在8s时任务3结束，调度器根据非抢占式最短作业优先调度策略选择任务2执行，任务2在8s继续执行；
在12s时任务2结束，任务全部完成。

过程符合非抢占式最短作业优先的调度策略。

甘特图：

计算等待时间为 (0 - 0) + (8 - 2) + (5 - 4) = 7
计算平均等待时间为 7 / 3 = 2.33s
计算也正确。

抢占式优先级调度策略：

可以看到，任务1在0s时开始执行；
在2s时任务2到达，运行着的任务1先阻塞，加入任务2后，由于任务2的优先级比任务1大，所以调度器根据抢占式优先级调度策略，选择任务2执行，任务2在2s时开始执行，任务1阻塞；
在4s时任务3到达，运行着的任务2先阻塞，加入任务3后，由于任务3的优先级比任务2小，所以调度器根据抢占式优先级调度策略继续选择任务2执行，任务2在4s时继续执行，任务3阻塞；
在6s时任务2结束，调度器根据抢占式优先级调度策略选择优先级更大的任务3执行，任务3在6s继续执行；
在9s时任务3结束，调度器根据抢占式优先级调度策略选择任务1执行，任务1在9s继续执行；
在12s时任务1结束，任务全部完成。

过程符合抢占式优先级的调度策略。

甘特图：

计算等待时间为 (9 - 2) + (2 - 2) + (6 - 4) = 9
计算平均等待时间为 9 / 3 = 3s
计算也正确。

非抢占式优先级调度策略：

可以看到，任务1在0s时开始执行；
在2s时任务2到达，运行着的任务1先阻塞，加入任务2后，虽然任务2的优先级比任务1大，但是调度器根据非抢占式优先级调度策略，继续选择任务1执行，任务1在2s时继续执行，任务2阻塞；
在4s时任务3到达，运行着的任务1先阻塞，加入任务3后，虽然任务3的优先级比任务1大，但是调度器根据非抢占式优先级调度策略继续选择任务1执行，任务1在4s时继续执行，任务3阻塞；
在5s时任务1结束，调度器根据非抢占式优先级调度策略选择优先级更大的任务2执行，任务2在5s继续执行；
在9s时任务2结束，调度器根据非抢占式优先级调度策略选择任务3执行，任务3在9s继续执行；
在12s时任务3结束，任务全部完成。

过程符合非抢占式优先级的调度策略。

甘特图：

计算等待时间为 (0 - 0) + (5 - 2) + (9 - 4) = 8
计算平均等待时间为 8 / 3 = 2.67s
计算也正确。

可以看出，各个调度算法基本正确。

测试用例2：

5
0 3 1
2 6 3
4 4 4
6 5 2
8 2 5
TaskArrival TimeWCTPriority
1031
2263
3444
4652
5825

执行截图：

甘特图：

[(0 - 0) + (3 - 2) + (9 - 4) + (13 - 6) + (18 - 8)] / 5 = 23 / 5 = 4.6

[(0 - 0) + (3 - 2 + 15 - 2) + (4 - 4) + (10 - 6) + (8 - 8)] / 5 = 18 / 5 = 3.6

[(0 - 0) + (3 - 2) + (11 - 4) + (15 - 6) + (9 - 8)] / 5 = 18 / 5 = 3.6

[(19 - 0) + (10 - 2) + (4 - 4) + (14 - 6) + (8 - 8)] / 5 = 33 / 5 = 6.6

[(0 - 0) + (3 - 2) + (11 - 4) + (15 - 6) + (9 - 8)] / 5 = 18 / 5 = 3.6

经过计算，结果基本正确。

测试用例3：

4
0 7 1
2 4 3
4 1 4
5 4 2
TaskArrival TimeWCTPriority
1071
2243
3414
4542

执行截图：

经过计算，结果基本正确。

测试用例4：

4
0 8 1
1 4 3
2 9 4
3 5 2
TaskArrival TimeWCTPriority
1081
2143
3294
4352

执行截图：

经过计算，结果基本正确。

StuGeek
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统知识点回顾—线程进程部分
程序员世杰
02-02 597
一、进程的通信方式 1.管道： 管道是单向的、先进先出的、无结构的、固定大小的字节流，它把一个进程的标准输出和另一个进程的标准输入连接在一起。写进程在管道的尾端写入数据，读进程在管道的道端读出数据。数据读出后将从管道中移走，其它读进程都不能再读到这些数据。管道提供了简单的流控制机制。进程试图读空管道时，在有数据写入管道前，进程将一直阻塞。同样地，管道已经满时，进程再试图写管道，在其它进程从管道中移...
《操作系统概念》笔记--第五章 进程调度
小菜鸟博客
02-13 1739
文章目录基本概念CPU－I/O执行周期CPU调度程序抢占调度调度程序调度准则调度算法先到先服务调度最短作业优先调度优先级调度轮转调度多级队列调度线程调度竞争范围多处理器调度多处理器调度的方法处理器亲和性负载平衡多核处理器实时CPU调度最小化延迟优先权调度单调速率调度最早截止期限优先调度比例分享调度小结比例分享调度小结 基本概念 CPU调度是多道程序操作系统的基础。通过在进程间切换CPU，操作系统可...
操作系统实验一 处理器调度
最新发布
m0_52448367的博客
01-27 972
本实验目的是模拟在单处理器情况下处理器调度，加深了解处理器调度的工作。要求是从优先级调度和时间片轮转法调度算法中选取一个进行实验。
CPU调度算法（操作系统实验）
11-23
多种CPU调度算法模拟（操作系统实验） C++
操作系统 第四次实验 CPU调度算法模拟实验
qq_45856311的博客
06-10 779
目标： • 1. 复习CPU调度的四种基本调度算法 • 2.复习平均等待时间以及平均周转时间 • 3. 通过编程模拟CPU调度的过程，深化对CPU的四种基本调度算法的理解 基本调度算法 • FCFS(先进先出算法) • SJF(短作业优先算法) • 优先级调度算法 • RR(时间片轮转调度算法) 等待时间和周转时间 • 等待时间 – 进程在等待队列中的时间总和 • 周转时间 – 进程从提交到进程完成的时间总和 实验内容 • 分别使用FCFS、 SJF（非抢占）、优先级调度（非抢占）、 RR四种调度算法来模拟
操作系统实验一：进程调度
05-31
操作系统实验一：进程调度 在计算机科学中，操作系统（Operating System, OS）是管理计算机硬件与软件资源的核心程序，它是计算机系统的关键组成部分。本实验主要关注的是操作系统中的一个核心概念——进程调度。...
SCAU操作系统实验报告源码 题目：调度算法
07-13
在本实验报告中，我们将深入探讨四种不同的调度算法：优先级调度（Priority）、时间片轮转（Round Robin, RR）、最短进程优先（Shortest Process Next, SPN）以及最短剩余时间优先（Shortest Remaining Time First, ...
操作系统实验一CPU调度
08-02
在"操作系统实验一CPU调度"中，我们将深入理解并实践CPU调度这一关键概念。CPU调度是操作系统内核的一项重要功能，其目标是高效、公平地分配处理器时间给各个正在运行的进程，确保系统的响应速度和整体性能。 实验...
基于Qt的操作系统实验一CPU调度：优先级调度&时间片轮转调度
10-31
利用Qt平台基于C++语言和可视化ui界面编写算法，实现动态CPU调度模拟系统。
操作系统CPU调度.pdf
04-05
操作系统实验报告 C语言模拟实现FIFO、SJF和优先权调度。内含实验原理、源码、运行结果。源码可运行
操作系统 处理器调度 实验报告
11-12
#include #include//调用STL中的优先队列 using namespace std; //定义一个PCB进程类 class PCB { public: char name[10];//进程的名字 int runtime;//该进程的运行时间 int priority;//该进程的优先级 char state;//该进程的状态 PCB* next;//指向下个进程的指针 void print()const//输出进程的信息 { cout<<" "<<name<<" "<<runtime<<" "<<state<<" "<<priority<<endl; } }; ……
操作系统处理机调度实验报告
12-07
操作系统处理机调度实验报告 1. 创建一个基于对话框的名为HW的工程。 2. 添加控件（包括3个按钮和9个static text控件和1个输入框）。 3. 将3个按钮的ID分别改为IDC_BUTTON_CREATE 、IDC_BUTTON_KILL 、IDC_BUTTON_CLOSE ，标题为 Create、Kill、Close；5个static text控件的ID为IDC_STATIC，标题为Queue(1)、Queue(2)、Queue(3)、Queue(4)、Time；输入框ID设置为ID_EDIT1 。 4. 把几个需要显示信息的控件绑定变量。 5. 分别给按钮“ Create ”,“ Kill ”,“ Close ”添加代码函数。 6. 编译调试运行。
操作系统实验报告（处理机调度算法的实现）
11-27
操作系统实验报告（处理机调度算法的实现）内容详细 1、实验名称： 处理机调度算法的实现 2、实验要求： 了解操作系统处理机调度概念的基本概念，处理机调度程序的功能，常用的处理机调度算法。C或C++编程方法与语句格式，提前初步编好试验程序。 3、实验方式： 通过实验室的微机上机，实际调试程序。 4、实验环境： Windows操作系统环境下的个人微机 Ｃ或Ｃ＋＋程序设计语言
多机调度问题
m0_58785888的博客
06-22 3621
一、问题分析 1、问题描述 2、提出问题 3、问题要求 二、算法思想 1、设计思路 2、 问题的解决方案 三、算法设计 1.设计方案 2.算法分析 2. 核心思想 3.运行代码 四、 结果与分析 1. 运行结果 2.算法思路 五、 总结 1、 完成情况 2、 心得体会 一、问题分析 1、问题描述 多机调度问题是生产管理与控制的一个基本问题。按照加工设备数量和加工作业的流云方式，一般可分为单机调度、并...
动态调度算法实验报告
qq_45917826的博客
03-25 1269
一、实验目的 1.理解操作系统进程管理中进行进程调度的过程和编程方法，创建进程控制块PCB。 2.理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。掌握几种调度算法。 3.理解几种进程调度的方式。 4.用代码将几种进程调度的方式表现出来。 二、实验原理 （1）先到先服务：按照进程提交给系统的先后次序来进行调度。 （2）短作业优先：按照进程所要求的运行时间来衡量。 （3）时间片轮转：根据先来先服务排序，以一个时间片为单位，依次执行不同的进程。 （4）响应比高者优先(HRRN)
CPU调度算法总结
热门推荐
Yates Law的博客
04-07 2万+
批处理系统中采用的调度算法重要指标（吞吐量，周转时间，CPU利用率，公平平衡） - 非抢占式的先来先服务算法（FCFS）：按照进程就绪的先后顺序使用CPU - 特点：公平，实现简单，但是长进程后面的短进程需要等待很长时间，不利于用户体验。 - 非抢占式的最短作业优先（SJF）：具有最短完成时间的进程优先执行 最短剩余时间优先（SRTN）：SJF抢占式版本，即当一个新就绪的进程比当前运行
操作系统实验一：处理器调度算法的实现
weixin_30624825的博客
04-15 832
（1）加深对处理机调度的作用和工作原理的理解。 （2）进一步认识并发执行的实质。 二、实验要求： 本实验要求用高级语言，模拟在单处理器情况下，采用多个调度算法，对N个进程进行进程调度。语言自选。 并完成实验报告。 三、实验内容： 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。 当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占...
linux 处理机调度,模拟linux操作系统下处理机调度实验报告(共9篇).doc
weixin_32859127的博客
05-15 295
模拟linux操作系统下处理机调度实验报告(共9篇)模拟linux操作系统下处理机调度实验报告(共9篇) 用C语言模拟Linux操作系统下处理机调度实验报告实验二：处理机调度一、实验目的：1、了解Linux下Emacs编辑器的使用方法，掌握各种常用的键盘操作命令；2、理解并掌握处理机调度算法。二、实验内容及要求：在采用多道系统的设计程序中，往往有若干进程同时处于就绪状态。当就绪状态进程数大于...
os实验报告.doc
01-09
实验报告 实验名称：进程调度算法 实验日期：2019年11月29日 实验者：西安工业大学计算机科学与技术专业，学号 ...希望本次实验能够加深同学对进程调度算法的理解，并对操作系统的设计和应用有所启发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值