进程调度程序设计报告(源代码)剖析
- 格式:doc
- 大小:375.71 KB
- 文档页数:19
一、实验目的通过本次实验,加深对进程调度原理和算法的理解,掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序,实现不同调度算法的模拟,并通过实验验证算法的性能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法:1. 先来先服务(FCFS)2. 最短作业优先(SJF)3. 时间片轮转(RR)四、实验步骤1. 定义进程类(Process):```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类(Scheduler):```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序:```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果:");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果:");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果(时间片为2):");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验,我们可以观察到以下结果:1. FCFS调度算法简单,但可能导致长作业等待时间过长。
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。
通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。
就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。
2、调度算法常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。
四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。
2. 掌握进程的创建、调度、同步和通信等操作。
3. 通过编程实现简单的进程管理功能。
二、实验环境1. 操作系统:Windows/Linux2. 编程语言:C/C++3. 开发环境:Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析(此处应填写实验结果,包括运行程序输出、图表等,以及对实验结果的分析。
一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块PCB,PCB用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器,一个保存正在或未进入就绪队列的进程,一个保存就绪的进程,另一个保存已完成的进程。
还有一个PCB实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。
主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时,用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。
进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架:开始选择调度算法void FCFS();//先来先服务void SJF();//最短进程优先调度void RR();//简单时间片轮转void PD();//最高优先数优先输入进程信息将输入容器中以满足进入条件的进程调入就绪队列判断就绪容器和输入容器是否为空!processScheduler.m_WaitQueue.empty()|| !processScheduler.m_ProcessQueue.empt() void ProcessQueueProcess();//查看当前时间下,有无进程加入。
若有则把该进程调入就绪队列void PCBInput();//输入进程信息Y打印各进程信息进行统计计算周转时间等结束void PCBDisplay();//打印当前状况下。
就绪队列、完成队列、运行中的进程信息void SchedulerStatistics();//调度统计,计算周转时间等按照选择的算法开始选择就绪队列的进程开始执行void ProcessSelect();//若当前就绪队列不为空则根据选择的调度算法开始调度,否则,系统时间加一个时间片.以等待新的进程到设计思路:(1)设计就绪、执行、完成三个队列;根据输入进程的时间,按照需要的时间越多,优先级越低,(60减去所需时间)建立就绪队列。
第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。
二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法:FCFS、RR和DP。
3. 创建一个进程队列,用于存储所有进程。
4. 实现调度函数,根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程,打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
操作系统原理(进程调度)实验报告实验一:动态优先权一.实验目的:(1).理解进程创建的相关理论;(2).掌握进程创建方法;(3).掌握进程相关的数据结构;(4).了解进程的调度算法;二.实验内容:1、最好采用图形界面;2、可随时增加进程;3、规定道数,设置后备队列和挂起状态。
若内存中进程少于规定道数,可自动从后备队列调度一作业进入。
被挂起进程入挂起队列,设置解挂功能用于将指定挂起进程解挂入就绪队列。
4、每次调度后,显示各进程状态。
三.实验步骤1.创建进程PCB。
包括进程ID,优先权,执行时间,占用cpu时间,状态五个部分;struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];2.初始化进程队列。
进程号用ID表示,优先权随机设定,状态均置为ready;void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}3.运行进程。
首轮按优先权大小排列进程执行顺序,优先权最大的最先执行,首轮执行后,运行程序优先权减2,未执行程序优先权加1.第二轮再按优先权顺序排序执行,以此类推,直到所有程序执行完成。
..........附录(源代码):#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 5enum STATE{ready,run,finish};struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];int Rseq[N];int flag = 0;int TIME = 0;void Print(){printf("=============================================================\n");printf(" id priority cputime alltime state \n");for(int i=0;i<N;i++){printf(" %d %d %d %d",process[i].id,process[i].priority,process[i].cputime,process[i].alltime);switch(process[i].state){case 0:printf("ready\n");break;case 1:printf("run\n");break;case 2:printf("finish\n");}}printf(" Next Run sequence :");for(int i=0;i<N;i++)if(i != N-1)printf("%d -> ",Rseq[i]);else printf("%d\n",Rseq[i]);printf("=============================================================\n\n"); }void Sort(){int temp;for(int i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if(process[Rseq[i]].priority <= process[Rseq[j]].priority){temp = Rseq[i];Rseq[i] = Rseq[j];Rseq[j] = temp;}}void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}void Run(){for(int i=0;i<=TIME;i++){printf(" run process:%d\n",Rseq[0]);for(int j=0;j<N;j++){if(process[j].state == run) process[j].state = ready;}for(int j=0;j<N;j++){if(process[Rseq[j]].alltime == 0){process[Rseq[j]].priority = 0;process[Rseq[j]].state = finish;}else if(j == 0 && process[Rseq[j]].alltime != 0){process[Rseq[j]].priority -= 2;process[Rseq[j]].cputime++;process[Rseq[j]].alltime--;process[Rseq[j]].state = run ;}else process[Rseq[j]].priority++;}Sort();Print();}}main(){Init();Run();}实验二:循环首次适应法(一)需求分析该算法是首次适应算法的变种。
一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法(先来先服务算法,短作业算法)分别进行模拟调度。
三、实验内容编程实现如下算法1.先来先服务算法;2.短作业算法四、实验代码1.先来先服务算法#include"stdio.h"#include"stdlib.h"typedef struct PCB //定义进程控制块{ char name[10]; //进程名char state; //运行状态int ArriveTime; //到达时间int StartTime; //进程开始时间int FinishTime; //进程结束时间int ServiceTime; //服务时间float WholeTime; //周转时间float WeightWholeTime;//带权周转时间double AverageWT_FCFS; //平均周转时间double AverageWWT_FCFS;//带权平均周转时间struct PCB *next; //指向下个进程}pcb;double x=0,y=0;int i;int time; //计时器int n; //进程个数pcb *head=NULL,*p,*q; //进程链表指针void run_FCFS(pcb *p1) //运行未完成的进程{time = p1->ArriveTime > time? p1->ArriveTime:time;p1->StartTime=time;printf("\n时刻:%d, 当前开始运行作业%s\n\n",time,p1->name);time+=p1->ServiceTime;p1->state='T';p1->FinishTime=time;p1->WholeTime=p1->FinishTime-p1->ArriveTime;p1->WeightWholeTime=p1->WholeTime/p1->ServiceTime;x+=p1->WholeTime;y+=p1->WeightWholeTime;p1->AverageWT_FCFS=p1->WholeTime/n;p1->AverageWWT_FCFS=p1->WeightWholeTime/n;printf(" 到达时间开始时间服务时间完成时间周转时间带权周转时间\n");printf("%6d %10d %10d %8d %10.1f %10.2f \n ",p1->ArriveTime,p1->StartTime,p1->ServiceTime,p1->FinishTime,p1->WholeTime,p1->WeightWholeTime);printf("\n平均周转时间平均带权周转时间\n");printf(" %10.2f %10.2f\n ",p1->AverageWT_FCFS,p1->AverageWWT_FCFS);}void FCFS() //找到当前未完成的进程{int i;p=head;for(i=0;i<n;i++){if(p->state=='F'){ q=p; //标记当前未完成的进程run_FCFS(q);}p=p->next;}}void getInfo() //获得进程信息并创建进程{int num;printf("\n进程个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));printf("依次输入:\n进程名到达时间服务时间\n");scanf("%s\t%d\t%d",&p->name,&p->ArriveTime,&p->ServiceTime);if(head==NULL){head=p;q=p;time=p->ArriveTime;}if(p->ArriveTime < time)time=p->ArriveTime;q->next=p;p->StartTime=0;p->FinishTime=0;p->WholeTime=0;p->WeightWholeTime=0;p->next=NULL;p->state='F';q=p;}}void main(){printf("先来先服务FCFS算法模拟\n");getInfo();p=head;FCFS();}2.短作业调度算法#include<iostream>#include<stdio.h>#include<iomanip>#include<queue>#include<deque>using namespace std;class JCB{public:int start,end,arrive,runtime,zhou,weizhou;string name;char state;void Show(){cout.width(9);cout<<name;cout.width(9);cout<<arrive;cout.width(11);cout<<runtime;cout.width(13);cout<<start;cout.width(10);cout<<end;cout.width(10);cout<<zhou;cout.width(9);cout<<(double)zhou/runtime<<endl;}bool operator<(const JCB& node)const{return arrive<node.arrive;}};int main(){int num;deque<JCB> Q;JCB jcb;cout<<"(SJF)请输入作业数目:";cin>>num;for(int i=1; i<=num; i++){cout<<"\n请输入作业名,到达时间,运行时间:";cin>>>>jcb.arrive>>jcb.runtime;jcb.state='W';Q.push_back(jcb);}deque<JCB>::iterator it,jt,current;current=Q.begin();current->start=current->arrive;current->end=current->start+current->runtime;current->zhou=current->end-current->arrive;current->state='R';for(int i=2; i<=num; i++){int flag=0;for(it=Q.begin(); it!=Q.end(); it++){if(flag==0)for(jt=Q.begin(); jt!=Q.end(); jt++)if(jt->state=='W') break;if(it->state=='W'&&it->arrive<=current->end&&it->runtime<jt->runtime){ jt=it; flag=1;}}if(jt->arrive<=current->end)jt->start=current->end;else jt->start=jt->arrive;jt->end=jt->start+jt->runtime;jt->zhou=jt->end-jt->arrive;jt->state='R';current=jt;}cout<<"\n作业名到达时间服务时间开始执行时间完成时间周转时间带权周转时间"<<endl;cout.setf(ios::left);double sum=0;while(!Q.empty()){jcb=Q.front();jcb.Show();sum+=(double )jcb.zhou/jcb.runtime;Q.pop_front();}cout<<"\n短作业优先算法(SJF)平均带权周转时间:"<<sum/num<<endl;return 0;}五、实验结果1.执行结果2.结果分析先来先服务调度算法就是根据进程达到的时间为依据,哪一个进程先来那么该进程就会先执行;最短进程优先调度算法则是以每个进程执行所需时间长短为依据,某一个进程执行所需花的时间要短些那么该进程就先执行。
课程设计报告题 目 进程调度程序设计课 程 名 称 操作系统课程设计院 部 名 称 计算机工程学院专 业 计算机科学与技术班 级 13计算机科学与技术(单)(1)学 生 姓 名 周敏健学 号 1305201013课程设计地点 A104课程设计学时 20学时指 导 教 师 何 健金陵科技学院教务处制 成绩目录摘要 (3)一、课程设计的目的和要求 (4)二、系统需求分析 (4)三、总体设计 (5)四、详细设计 (6)五、测试、调试过程 (9)六、结论与体会 (11)七、参考文献 (12)附录:源程序 (12)课程设计课题进程调度程序设计摘要在多道系统中,对批处理作业需要进行作业调度。
作业调度是在资源满足的条件下,将处于就绪状态的作业调入存,同时生成与作业相对应的进程,并未这些进程提供所需要的资源。
进程调度需要根据进程控制块(PCB)中的信息,检查系统是否满足进程的资源需求。
只有在满足进程的资源需求的情况下,系统才能进行进程调度。
下面是几种常见的作业调度算法:先来先服务(FCFS)、优先算法、轮换算法、短作业优先算法以及最高响应比优先法等,本文将对前两种算法进行详细的介绍。
关键词:进程调度,优先级,FCFS,PCB,作业,资源一、课程设计的目的和要求1、目的进程调度是处理机管理的核心容。
本设计要求用C语言编写和调试一个简单的进程调度程序。
通过设计本可以加深理解有关进程控制块、进程队列的概念,并体会和了解最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法的具体实施办法。
2、要求1)进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
2)每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3)进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程管理实验报告1. 实验目的:(1)加深对进程概念的理解, 明确进程和程序的区别;(2)进一步认识并发执行的实质;(3)分析进程争用资源的现象, 学习解决进程互斥的方法;(4)了解Linux系统中进程通信的基本原理。
2. 实验预备内容(1)阅读Linux的sched.h源码文件, 加深对进程管理概念的理解;(2)阅读Linux的fork()源码文件, 分析进程的创建过程。
3.环境说明本次实验使用的是win7下的VMWare workstation虚拟机, 安装了ubuntu系统在ubuntu系统下使用code::blocks IDE编写代码并执行程序的4.实验内容:1.进程的创建:(1)实验题目和要求:编写一段程序, 使用系统调用fork() 创建两个子进程。
当此程序运行时, 在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”, 子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果, 并分析原因。
(2)程序设计说明:参照书上的例子进行设计, 详见源代码(3)程序运行结果截图:(4)程序分析:a,b,c随机出现, 因为父进程与两个子进程之间并没有同步措施, 所以a,b,c随机打印出来, 也就是三个进程的活动次序是随机进行的, 不同的系统可能有不同的进程调度方式。
(5)源程序:#include<sys/types.h>#include<stdio.h>#include<unistd.h>int main(){pid_t pid1,pid2;if((pid1=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid1=fork())==0)printf("b\n");else{if((pid2=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid2=fork())==0)printf("c\n");else{wait(NULL);printf("a\n");exit(0);}}return 0;}2.进程的控制:要求一:(1)实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。
XXXXXX计算机系综合性实验实验报告课程名称操作系统B实验学期XXXX 至XXXX 学年第X 学期学生所在系部计算机系年级XXXX 专业班级XXXXXX学生姓名XXXX 学号XXXXXXXXXXXX任课教师XXX实验成绩计算机系制《操作系统B 》课程综合性实验报告开课实验室:年月日附代码:#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10]; //进程的名字int round; //一次分配CPU的时间片int cputime; //CPU已执行时间int needtime; //进程执行所需要的时间char state; //进程的状态,W-就绪态,R-执行态,F-完成态int count; //记录进程执行的次数struct node *next; //队列指针}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; //定义三个队列,就绪队列,执行队列和完成队列int num;void GetFirst(); //从就绪队列取得第一个节点void Output(); //输出各队列信息void InsertTime(PCB *in); //插入就绪片队列void InsertFinish(PCB *in); //插入完成队列void TimeCreate(); //时间片输入函数void RoundRun(); //时间片轮转调度void main(){printf("\n****** 欢迎光临指导******\n");printf("\n****** 时间片轮转进程调度算法******\n");printf("\n****** 计科B082 韩友******\n");printf("\n****** 200807014225 ******\n");printf("\n****** 2011年5月15日******\n");printf("\n请输入要创建的进程数目:\n");scanf("%d",&num);getchar(); //吸收回车符号TimeCreate();RoundRun();Output();}void GetFirst() //取得第一个就绪队列节点{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() //输出队列信息{PCB *p;p = ready;printf("进程轮数cpu时间需要时间进程状态计数器\n");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertTime(PCB *in) //将进程插入到就绪队列尾部{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) //将进程插入到完成队列尾部{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL)fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void TimeCreate() //时间片轮转输入函数{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->round = 2; //假设每个进程所分配的时间片是2tmp ->count = 0;InsertTime(tmp);}}void RoundRun() //时间片轮转调度算法{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) //进程执行完毕{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)//时间片用完{run->state = 'W';run->count = 0; //计数器清零,为下次做准备InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。