操作系统实验——作业调度算法模拟

最新推荐文章于 2025-02-11 17:46:14 发布
最新推荐文章于 2025-02-11 17:46:14 发布
阅读量1.4k 收藏 14
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chigenb/article/details/107112005
版权 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXJOB  50
typedef struct node
{
	int number;       
	int reach_time;
	int need_time;
	int privilege;
	float excellent;
	int start_time;
	int wait_time;
	int visited;
}job;
job jobs[MAXJOB];
int quantity;
void initial_jobs()
{
	int i;
	for (i = 0; i < MAXJOB; i++)
	{
		jobs[i].number = 0;
		jobs[i].reach_time = 0;
		jobs[i].privilege = 0;
		jobs[i].excellent = 0;
		jobs[i].start_time = 0;
		jobs[i].wait_time = 0;
		jobs[i].visited = 0;
	}
	quantity = 0;
}
void readJobdata()
{
	FILE *fp;
	char fname[20];
	int i;
	printf("please input job data file name\n");
	scanf("%s", fname);
	if ((fp = fopen(fname, "r")) == NULL)
	{
		printf("error, open file failed, please check filename:\n");
	}
	else
	{
		while (!feof(fp))
		{
			if (fscanf(fp, "%d %d %d %d", &jobs[quantity].number, &jobs[quantity].reach_time, &jobs[quantity].need_time, &jobs[quantity].privilege) == 4)
				quantity++;
		}
		printf("output the origin job data\n");
		printf("---------------------------------------------------------------------\n");
		printf("\tjobID\treachtime\tneedtime\tprivilege\n");
		for (i = 0; i < quantity; i++)
		{
			printf("\t%-8d\t%-8d\t%-8d\t%-8d\n", jobs[i].number, jobs[i].reach_time, jobs[i].need_time, jobs[i].privilege);
		}
	}
}
void reset_jinfo()
{
	int i;
	for (i = 0; i < MAXJOB; i++)
	{
		jobs[i].start_time = 0;
		jobs[i].wait_time = 0;
		jobs[i].visited = 0;
	}
}
int findrearlyjob(job jobs[], int count)
{
	int rearlyloc = -1;
	int rearlyjob = -1;
	for (int i = 0; i < count; i++)
	{
		if (rearlyloc == -1)
		{
			if (jobs[i].visited == 0)
			{
				rearlyloc = i;
				rearlyjob = jobs[i].reach_time;
			}
		}
		else if (rearlyjob > jobs[i].reach_time&&jobs[i].visited == 0)
		{
			rearlyjob = jobs[i].reach_time;
			rearlyloc = i;
		}
	}
	return rearlyloc;
}
int findminjob(job jobs[], int count, int current_time)
{
	int minjob = -1;
	int minloc = -1;
	for (int i = 0; i < count; i++)
	{
		if (minloc == -1) 
		{
			if (jobs[i].reach_time <= current_time && jobs[i].visited == 0) 
			{
				minjob = jobs[i].need_time;
				minloc = i;
			}
		}
		else if (minjob > jobs[i].need_time&&jobs[i].visited == 0 && jobs[i].reach_time <= current_time)
		{
			minjob = jobs[i].need_time;
			minloc = i;
		}
		else if (minjob == jobs[i].need_time&&jobs[i].visited == 0 && jobs[i].reach_time <= current_time && jobs[minloc].reach_time > jobs[i].reach_time)
		{
			minloc = i;
		}
	}
	if (minloc == -1)
		minloc = findrearlyjob(jobs, quantity);
	return minloc;
}
int findhighprivilegejob(job jobs[], int count, int current_time)
{
	int t;
	int privilegejob = -1;
	int privilegeloc = -1;
	int privilege = -1;
	for (int i = 0; i < count; i++)
	{
		if (privilegeloc == -1)
		{
			if (jobs[i].reach_time <= current_time && jobs[i].visited == 0)
			{
				privilege = jobs[i].privilege;
				privilegejob = jobs[i].need_time;
				privilegeloc = i;
			}
		}
		else if (privilege < jobs[i].privilege&&jobs[i].visited == 0 && jobs[i].reach_time <= current_time)
		{
			privilege = jobs[i].privilege;
			privilegejob = jobs[i].need_time;
			privilegeloc = i;
		}
		else if (privilege == jobs[i].privilege&&jobs[i].visited == 0 && jobs[i].reach_time <= current_time && privilegejob > jobs[i].need_time)
		{
			privilegejob = jobs[i].need_time;
			privilegeloc = i;
		}
	}
	if (privilegeloc == -1)
		privilegeloc = findrearlyjob(jobs, quantity);
	return privilegeloc;
}
int findhrrfjob(job jobs[], int count, int current_time)
{
	int hrrfjob = -1;
	int hrrfloc = -1;
	float responsejob = -1.0;
	for (int i = 0; i < count; i++)
	{
		if (hrrfloc == -1)
		{
			if (jobs[i].reach_time <= current_time && jobs[i].visited == 0)
			{
				hrrfjob = jobs[i].need_time;
				responsejob = (float)(current_time - jobs[i].reach_time + jobs[i].need_time) / jobs[i].need_time;
				hrrfloc = i;
			}
		}
		else if (responsejob < ((float)(current_time - jobs[i].reach_time + jobs[i].need_time) / jobs[i].need_time)&&jobs[i].visited == 0 && jobs[i].reach_time <= current_time)
		{
			responsejob = (float)(current_time - jobs[i].reach_time + jobs[i].need_time) / jobs[i].need_time;
			hrrfjob = jobs[i].need_time;
			hrrfloc = i;
		}
		else if (responsejob == ((float)(current_time - jobs[i].reach_time + jobs[i].need_time) / jobs[i].need_time) &&jobs[i].visited == 0 && jobs[i].reach_time <= current_time && hrrfjob > jobs[i].need_time)
		{
			hrrfjob = jobs[i].need_time;
			hrrfloc = i;
		}
	}
	if (hrrfloc == -1)
		hrrfloc = findrearlyjob(jobs, quantity);
	return hrrfloc;
}
void FCFS()
{
	int i;
	int current_time = 0;
	int loc;
	int total_waitime = 0;
	int total_roundtime = 0;
	loc = findrearlyjob(jobs, quantity);
	printf("\n\nFCFS算法作业流\n");
	printf("------------------------------------------------------------------------\n");
	printf("\tjobID\treachtime\tstarttime\twaittime\troundtime\n");
	current_time = jobs[loc].reach_time;

	for (i = 0; i < quantity; i++)
	{
		if (jobs[loc].reach_time > current_time)
		{
			jobs[loc].start_time = jobs[loc].reach_time;
			current_time = jobs[loc].reach_time;
		}
		else
		{
			jobs[loc].start_time = current_time;
		}
		jobs[loc].wait_time = current_time - jobs[loc].reach_time;
		printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time,
			jobs[loc].wait_time + jobs[loc].need_time);
		jobs[loc].visited = 1;
		current_time += jobs[loc].need_time;
		total_waitime += jobs[loc].wait_time;
		total_roundtime = total_roundtime + jobs[loc].wait_time + jobs[loc].need_time;
		loc = findrearlyjob(jobs, quantity);
	}
	printf("总等待时间:%-8d 总周转时间:%-8d\n", total_waitime, total_roundtime);
	printf("平均等待时间: %4.2f 平均周转时间: %4.2f\n", (float)total_waitime / (quantity), (float)total_roundtime / (quantity));
}
void SFJschdulejob(job jobs[], int count)
{
	int i;
	int current_time = 0;
	int loc;
	int total_waitime = 0;
	int total_roundtime = 0;
	loc = findrearlyjob(jobs, quantity);
	printf("\n\nSFJ算法作业流\n");
	printf("------------------------------------------------------------------------\n");
	printf("\tjobID\treachtime\tstarttime\twaittime\troundtime\n");
	current_time = jobs[loc].reach_time;
	jobs[loc].start_time = jobs[loc].reach_time;
	jobs[loc].wait_time = 0;
	printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time,jobs[loc].wait_time + jobs[loc].need_time);
	jobs[loc].visited = 1;
	current_time += jobs[loc].need_time;
	total_waitime = 0;
	total_roundtime = jobs[loc].need_time;
	loc = findminjob(jobs, quantity, current_time);
	for (i = 1; i < quantity; i++)
	{
		if (jobs[loc].reach_time > current_time)
		{
			jobs[loc].start_time = jobs[loc].reach_time;
			current_time = jobs[loc].reach_time;
		}
		else
		{
			jobs[loc].start_time = current_time;
		}
		jobs[loc].wait_time = current_time - jobs[loc].reach_time;
		printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time,
			jobs[loc].wait_time + jobs[loc].need_time);
		jobs[loc].visited = 1;
		current_time += jobs[loc].need_time;
		total_waitime += jobs[loc].wait_time;
		total_roundtime = total_roundtime + jobs[loc].wait_time + jobs[loc].need_time;
		loc = findminjob(jobs, quantity, current_time);
	}
	printf("总等待时间:%-8d 总周转时间:%-8d\n", total_waitime, total_roundtime);
	printf("平均等待时间: %4.2f 平均周转时间: %4.2f\n", (float)total_waitime / (quantity), (float)total_roundtime / (quantity));
}
void HPF(job jobs[], int count)
{
	int i;
	int current_time = 0;
	int loc;
	int total_waitime = 0;
	int total_roundtime = 0;
	loc = findrearlyjob(jobs, quantity);
	printf("\n\nHPF算法作业流\n");
	printf("------------------------------------------------------------------------\n");
	printf("\tjobID\treachtime\tstarttime\twaittime\troundtime\n");
	current_time = jobs[loc].reach_time;
	jobs[loc].start_time = jobs[loc].reach_time;
	jobs[loc].wait_time = 0;
	printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time, jobs[loc].wait_time + jobs[loc].need_time);
	jobs[loc].visited = 1;
	current_time += jobs[loc].need_time;
	total_waitime = 0;
	total_roundtime = jobs[loc].need_time;
	loc = findhighprivilegejob(jobs, quantity, current_time);
	for (i = 1; i < quantity; i++)
	{
		if (jobs[loc].reach_time > current_time)
		{
			jobs[loc].start_time = jobs[loc].reach_time;
			current_time = jobs[loc].reach_time;
		}
		else
		{
			jobs[loc].start_time = current_time;
		}
		jobs[loc].wait_time = current_time - jobs[loc].reach_time;
		printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time,
			jobs[loc].wait_time + jobs[loc].need_time);
		jobs[loc].visited = 1;
		current_time += jobs[loc].need_time;
		total_waitime += jobs[loc].wait_time;
		total_roundtime = total_roundtime + jobs[loc].wait_time + jobs[loc].need_time;
		loc = findhighprivilegejob(jobs, quantity, current_time);
	}
	printf("总等待时间:%-8d 总周转时间:%-8d\n", total_waitime, total_roundtime);
	printf("平均等待时间: %4.2f 平均周转时间: %4.2f\n", (float)total_waitime / (quantity), (float)total_roundtime / (quantity));
}
void HRRF(job jobs[], int count)
{
	int i;
	int current_time = 0;
	int loc;
	int total_waitime = 0;
	int total_roundtime = 0;
	loc = findrearlyjob(jobs, quantity);
	printf("\n\nHRRF算法作业流\n");
	printf("------------------------------------------------------------------------\n");
	printf("\tjobID\treachtime\tstarttime\twaittime\troundtime\n");
	current_time = jobs[loc].reach_time;
	jobs[loc].start_time = jobs[loc].reach_time;
	jobs[loc].wait_time = 0;
	printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time, jobs[loc].wait_time + jobs[loc].need_time);
	jobs[loc].visited = 1;
	current_time += jobs[loc].need_time;
	total_waitime = 0;
	total_roundtime = jobs[loc].need_time;
	loc = findhrrfjob(jobs, quantity, current_time);
	for (i = 1; i < quantity; i++)
	{
		if (jobs[loc].reach_time > current_time)
		{
			jobs[loc].start_time = jobs[loc].reach_time;
			current_time = jobs[loc].reach_time;
		}
		else
		{
			jobs[loc].start_time = current_time;
		}
		jobs[loc].wait_time = current_time - jobs[loc].reach_time;
		printf("\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n", loc + 1, jobs[loc].reach_time, jobs[loc].start_time, jobs[loc].wait_time,
			jobs[loc].wait_time + jobs[loc].need_time);
		jobs[loc].visited = 1;
		current_time += jobs[loc].need_time;
		total_waitime += jobs[loc].wait_time;
		total_roundtime = total_roundtime + jobs[loc].wait_time + jobs[loc].need_time;

		loc = findhrrfjob(jobs, quantity, current_time);
	}
	printf("总等待时间:%-8d 总周转时间:%-8d\n", total_waitime, total_roundtime);
	printf("平均等待时间: %4.2f 平均周转时间: %4.2f\n", (float)total_waitime / (quantity), (float)total_roundtime / (quantity));
}
int main()
{
	initial_jobs();
	readJobdata();
	FCFS();
	reset_jinfo();
	SFJschdulejob(jobs, quantity);
	reset_jinfo();
	HRRF(jobs, quantity);
	reset_jinfo();
	HPF(jobs, quantity);
	system("pause");
	return 0;
}

在这里插入图片描述在这里插入图片描述

Hebuter-2018
关注
操作系统实验——磁盘调度算法（FIFS SSTF SCAN）
bct的博客
06-21 1万+
操作系统实验——磁盘调度算法（FIFS SSTF SCAN） 一、实验目的 1、了解磁盘调度的策略和原理； 2、理解和掌握磁盘调度算法——先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、电梯扫描算法（SCAN）。 二、实验内容 1、模拟先来先服务法（First-Come, First-Served，FCFS），最短寻道时间优先法（Shortest Seek Time First， SSTF），电梯扫描算法（SCAN）三种磁盘调度算法； 2、对三种算法进行对比分析。 3、输入为一组请求访问磁道序
操作系统实验（作业调度算法源代码）
07-21
操作系统实验（作业调度算法源代码），包括3个作业调度：先来先服务、最高响应比和短作业优先
操作系统实验-6，作业调度算法模拟
ALAN_CF的博客
06-01 1591
实验6，作业调度算法模拟 1）先来先服务（First-Come First-Served，FCFS）调度算法 先来先服务调度算法遵循按照进入后备队列的顺序进行调度的原则。该算法是一种非抢占式的算法，是到目前为止最简单的调度算法，其编码实现非常容易。该算法仅考虑了作业到达的先后顺序，而没有考虑作业的执行时间长短、作业的运行特性和作业对资源的要求。 2）短作业优先（Shortest-Job-First，SJF）调度算法 短作业优先调度算法根据作业控制块中指出的执行时间，选取执行时间最短的作业优先调度。本实验中规
操作系统的任务调度算法
最新发布
2301_80320652的博客
02-11 824
在多任务系统中，多个进程同时竞争 CPU，合理的调度算法可以。，决定哪个进程先执行、执行多长时间，以及何时切换任务。任务调度（Task Scheduling）是指。（短作业不断到达，长作业可能一直得不到执行）。，它直接影响系统性能，因此本文主要探讨。轮流执行，超时后切换到下一个进程。，减少平均等待时间。
作业调度算法的仿真
Echol_sue的博客
12-13 1611
目录 一、实验要求 二、实验内容 三、实验过程 1、实验过程中的存储结构和关键函数 2、主要程序段分析 四、实验结果展示 四、实验分析 一、实验要求 编程完成对先来先服务、短作业优先和高响应比优先三种作业调度算法，并在实验报告中分析这三种方法的特性。 二、实验内容 1、模拟系统随时都可能会收到作业，在执行作业的过程中也是要实时能够接收到新提交的作业，并更新加入作业后备队列中。 2、模拟系统作业调度的流程，在系统空闲时，有作业来会触发...
短作业优先调度算法的模拟（C++实现）
falldeep的算法世界
05-14 3481
设置参数 设置了四个作业进行实验 根据计算，根据先到先服务算法，得出作业的调度流程图 运行程序，得出程序运行结果 通过对比可以发现，程序运行正确，并且程序还可以输出，每一秒运行的状态，参数包括正在运行的进程名，开始运行时间，及当前就绪队列中的进程名 流程图 源码 #include<iostream> using namespace std; const int N = 20; int h[N], hh, tt = -1;//用数组模拟队列，就绪队...
实验六 作业调度算法模拟
m0_74644005的博客
06-06 706
优先权高者优先调度算法与响应比高者优先调度算法十分相似，根据作业的优先权进行作业调度，每次总是选取优先权高的作业优先调度。优先权高者优先调度算法综合考虑了作业执行时间和等待时间的长短、作业的缓急度，作业对外部设备的使用情况等因素，根据系统设计目标和运行环境而给定各个作业的优先权，决定作业调度的先后顺序。FCFS调度算法只片面地考虑了作业的进入时间，短作业优先调度算法考虑了作业的运行时间而忽略了作业的等待时间。该算法仅考虑了作业到达的先后顺序，而没有考虑作业的执行时间长短、作业的运行特性和作业对资源的要求。
操作系统磁盘调度算法实验报告
05-07
操作系统磁盘调度算法实验报告 本实验报告的主要目的是设计一个磁盘调度模拟系统，旨在使磁盘调度算法更加形象化、易于理解，使磁盘调度的特点更简单明了。通过本实验，学生可以加深对先来先服务算法、最短寻道时间...
操作系统课程设计——页面置换算法模拟实现
02-24
设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰算法（OPT），最近最久未使用算法（LRU）计算不同内存容量下的缺页率，模拟表示出不同算法内存中页面的变化情况，并对不同内存容量下...
操作系统实验六–作业调度算法模拟.pdf
12-22
操作系统实验六——作业调度算法模拟主要探讨了四种不同的作业调度算法，这些算法在操作系统中用于决定如何有效地分配CPU资源给等待执行的作业。以下是这四种调度算法的详细说明： 1. **先来先服务（FCFS）调度算法...
操作系统实验C语言编写——作业调度.doc
12-22
操作系统实验C语言编写——作业调度 以下是本次实验的知识点总结： 1. 操作系统实验的目的：本次实验的目的是通过C语言编写一个模拟批处理多道操作系统的作业调度程序，了解作业调度在操作系统中的作用。 2. 作业...
操作系统调度算法实验报告
12-03
操作系统关于系统调度算法的实验报告：包括先来先服务调度算法、短作业优先调度算法和响应比高者优先调度算法在单道以及多道环境下的优劣势比较。
作业调度算法的模拟举例
04-12
调度算法模拟——操作系统作业调度算法模拟
操作系统实验——多道作业调度算法
06-30
操作系统实验，多道作业调度算法，共分3道，简易模拟。
操作系统作业调度算法实验报告
12-23
本实验报告为课程实验报告，内容齐全，详细介绍了操作系统中作业调度算法。
FCFS和SJF作业调度算法模拟
12-17
FCFS和SJF作业调度算法模拟 带源代码 带源程序 可以直接使用
操作系统作业调度算法模拟
yc21st的专栏
04-01 197
操作系统作业调度
操作系统·用Java模拟作业调度算法
m0_55006433的博客
09-18 1170
用Java模拟四种常用的作业调度算法（FCFS、SJF、HPF、HRRN）。
作业调度算法模拟
懒羊羊的梦想
06-12 2887
作业调度算法模拟 1）先来先服务（First-Come First-Served，FCFS）调度算法 先来先服务调度算法遵循按照进入后备队列的顺序进行调度的原则。该算法是一种非抢占式的算法，是到目前为止最简单的调度算法，其编码实现非常容易。该算法仅考虑了作业到达的先后顺序，而没有考虑作业的执行时间长短、作业的运行特性和作业对资源的要求。 2）短作业优先（Shortest-Job-First，SJF）调度算法 短作业优先调度算法根据作业控制块中指出的执行时间，选取执行时间最短的作业优先调度。本实验中规定，该
操作系统实验：作业调度算法对比——FCFS与SJF
"该实验涉及操作系统中的作业调度算法，包括先到先服务(FCFS)、短作业优先(SJF)以及响应比高者优先三种策略，并提供了运行结果的展示。" 在操作系统中，作业调度是核心功能之一，用于决定系统如何在多个等待执行的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值