重庆大学操作系统实验二(线程及其调度)

合集下载

操作系统实验-进程调度2

操作系统实验-进程调度2
#defineMAX_TIME 0xFF//最大时间
//状态宏
#defineWAIT 0x01
#defineRUN 0x02
#defineFINISH 0x03
#defineID_ERROR 0x10
#defineMIN_PRIOR 0xFF
#defineMAX_PRIOR 0x00
//自定义数据类型
{
if(g_queue[i].s_state!=FINISH)
{
temp_prior = g_queue[i].s_dynamic_prior * 100 + g_queue[i].s_static_prior;
if(temp_prior <= prior)
{
id = i;
prior = temp_prior;
{
Work_Process(id);
}
}
Uint32 Get_PriProceபைடு நூலகம்s()
{
Uint32 id = ID_ERROR;
inti,prev_id = ID_ERROR;
Uint32 prior = MIN_PRIOR * 2, temp_prior;
for(i=0;i<PRO_NUM;++i)
{
inti =0;
Uint32 id = ID_ERROR;
for(i = 0;i<PRO_NUM;++i)
{
if(g_queue[i].s_state==FINISH)
{
id = g_queue[i].s_id;
g_queue[i].s_dynamic_prior = 0;
g_queue[i].s_need_time =needtime;

操作系统实验二实验报告

操作系统实验二实验报告

操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术,包括进程的创建、执行、同步和通信。

通过实际编程和实验操作,提高对操作系统原理的认识,培养解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程环境为 Visual Studio 2019。

三、实验内容及步骤(一)进程创建实验1、首先,创建一个新的 C++项目。

2、在项目中,使用 Windows API 函数`CreateProcess`来创建一个新的进程。

3、为新进程指定可执行文件的路径、命令行参数、进程属性等。

4、编写代码来等待新进程的结束,并获取其退出代码。

(二)进程同步实验1、设计一个生产者消费者问题的模型。

2、使用信号量来实现生产者和消费者进程之间的同步。

3、生产者进程不断生成数据并放入共享缓冲区,当缓冲区已满时等待。

4、消费者进程从共享缓冲区中取出数据进行处理,当缓冲区为空时等待。

(三)进程通信实验1、选择使用管道来实现进程之间的通信。

2、创建一个匿名管道,父进程和子进程分别读写管道的两端。

3、父进程向管道写入数据,子进程从管道读取数据并进行处理。

四、实验结果及分析(一)进程创建实验结果成功创建了新的进程,并能够获取到其退出代码。

通过观察进程的创建和执行过程,加深了对进程概念的理解。

(二)进程同步实验结果通过使用信号量,生产者和消费者进程能够正确地进行同步,避免了缓冲区的溢出和数据的丢失。

分析结果表明,信号量机制有效地解决了进程之间的资源竞争和协调问题。

(三)进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。

数据能够准确地在进程之间传递,验证了管道通信的有效性。

五、遇到的问题及解决方法(一)在进程创建实验中,遇到了参数设置不正确导致进程创建失败的问题。

通过仔细查阅文档和调试,最终正确设置了参数,成功创建了进程。

(二)在进程同步实验中,出现了信号量使用不当导致死锁的情况。

计算机操作系统实验二

计算机操作系统实验二

计算机操作系统实验二一、实验目的本实验旨在通过实际操作,深入理解和掌握计算机操作系统中的进程与线程管理。

通过实验,我们将了解进程的创建、执行、阻塞、唤醒等状态以及线程的创建、同步、通信等操作。

同时,通过实验,我们将学习如何利用进程和线程提高程序的并发性和效率。

二、实验内容1、进程管理a.进程的创建与执行:通过编程语言(如C/C++)编写一个程序,创建一个新的进程并执行。

观察和记录进程的创建、执行过程。

b.进程的阻塞与唤醒:编写一个程序,使一个进程在执行过程中发生阻塞,并观察和记录阻塞状态。

然后,通过其他进程唤醒该进程,并观察和记录唤醒过程。

c.进程的状态转换:根据实际操作,理解和分析进程的状态转换(就绪状态、阻塞状态、执行状态)以及转换的条件和过程。

2、线程管理a.线程的创建与同步:编写一个多线程程序,创建多个线程并观察和记录线程的创建过程。

同时,使用同步机制(如互斥锁或信号量)实现线程间的同步操作。

b.线程的通信:通过消息队列或其他通信机制,实现多个线程间的通信。

观察和记录线程间的通信过程以及通信对程序执行的影响。

c.线程的状态转换:根据实际操作,理解和分析线程的状态转换(新建状态、就绪状态、阻塞状态、终止状态)以及转换的条件和过程。

三、实验步骤1、按照实验内容的要求,编写相应的程序代码。

2、编译并运行程序,观察程序的执行过程。

3、根据程序的输出和实际操作情况,分析和理解进程与线程的状态转换以及进程与线程管理的相关原理。

4、修改程序代码,尝试不同的操作方式,观察程序执行结果的变化,进一步深入理解和掌握进程与线程管理。

5、完成实验报告,总结实验过程和结果,提出问题和建议。

四、实验总结通过本次实验,我们深入了解了计算机操作系统中的进程与线程管理原理和实践操作。

在实验过程中,我们不仅学习了如何利用编程语言实现进程和线程的操作,还通过实际操作观察和分析了进程与线程的状态转换以及进程与线程管理的基本原理。

线程调度实习报告

线程调度实习报告

线程调度实习报告姓名李炜学号1100012810日期2014年3月6日目录内容一:总体概述 (3)内容二:任务完成情况 (3)任务完成列表(Y/N) (3)具体Exercise的完成情况 (3)内容三:遇到的困难以及解决方法 (7)内容四:收获及感想 (7)内容五:对课程的意见和建议 (7)内容六:参考文献 (8)内容一:总体概述这次的实习任务主要是通过对Nachos线程的调度机制来加深对线程调度的理解,因为Nachos本身是没有很复杂的调度机制的,所以这次实习中需要首先向Nachos添加带有优先级的线程调度算法,之后添加使用时间片调度,来使得线程的调度相对公平。

内容二:任务完成情况任务完成列表(Y/N)具体Exercise的完成情况第一部分Exercise1首先来看windows的线程调度,windows的调度单位就是线程,它采用的时基于动态优先级的、抢占式调度,结合时间配额调整,总是运行最高优先级线程。

就绪线程会按优先级进入相应队列,系统总是选择优先级最高的就绪线程让其运行,同一优先级的各线程按时间片轮转进行调度,多处理机系统中允许多个线程并行运行。

从这一点来看,有些像多级反馈队列调度的方法。

线程调度的触发事件有四种:一个线程进入就绪状态,如一个刚创建的新线程或一个刚刚结束等待状态的线程一个线程由于时间配额用完、从运行状态转入结束状态或等待状态一个线程由于调用系统服务而改变优先级或被Windows 系统本身改变其优先级一个正在运行的线程改变了它的亲合处理机集合Windows使用32个线程优先级,分成三类,实时优先级,可变优先级,系统线程(IDLE)。

一个线程用完了自己的时间配额时,如果没有其它相同优先级线程,Windows将重新给该线程分配一个新的时间配额,并继续运行。

当线程被抢占时,它被放回相应优先级的就绪队列的队首处于实时优先级的线程在被抢占时,时间配额被重置为一个完整的时间配额处于动态优先级的线程在被抢占时,时间配额不变,重新得到处理机后将运行直到剩余的时间配额用完如果刚用完时间配额的线程优先级降低了,Windows 将寻找一个优先级高于刚用完时间配额线程的新设置值的就绪线程如果刚用完时间配额的线程的优先级没有降低,并且有其他优先级相同的就绪线程,Windows 将选择相同优先级的就绪队列中的下一个线程进入运行状态,刚用完时间配额的线程被排到就绪队列的队尾(即分配一个新的时间配额并把线程状态从运行状态改为就绪状态)配额并继续运行下面来看linux的线程调度策略,linux将进程分为下面两类实时进程对调度延迟的要求最高,要求立即响应并执行调度策略:FIFO、Round Robin普通进程普通进程调度策略使用CFS,CFS是现在被内核采纳的调度器。

操作系统实验二并发与调度

操作系统实验二并发与调度

实验二并发与调度一、实验目的在本实验中,通过对事件和互斥体对象的了解,来加深对Windows 2000线程同步的理解。

通过分析实验程序,了解管理事件对象的API。

了解在进程中如何使用事件对象,在进程中如何使用互斥体对象,线程如何通过文件映射对象发送数据。

二、实验环境硬件环境:计算机一台,局域网环境;软件环境:Windows 2000 Professional,Visual C++ 6.0专业版或企业版。

三、实验内容和步骤第一部分:互斥体对象本程序中显示的类CCountUpDown使用了一个互斥体来保证对两个线程间单一数值的访问。

每个线程都企图获得控制权来改变该数值,然后将该数值写入输出流中。

创建者实际上创建的是互斥体对象,计数方法执行等待并释放,为的是共同使用互斥体所需的资源(因而也就是共享资源) 。

1、利用互斥体保护共享资源程序参见实验指导书分析程序的运行结果,可以看到线程(加和减线程) 的交替执行(因为Sleep() API允许Windows切换线程) 。

在每次运行之后,数值应该返回初始值(0) ,因为在每次运行之后写入线程在等待队列中变成最后一个,内核保证它在其他线程工作时不会再运行。

1)请描述运行结果(如果运行不成功,则可能的原因是什么?) :2) 根据运行输出结果,对照分析程序,可以看出程序运行的流程吗?请简单描述:_____逆向运行__________第二部分线程通过文件对象发送数据Windows 2000提供的线程间通讯类内核对象允许同一进程或跨进程的线程之间互相发送信息,包括文件、文件映射、邮件位和命名管道等,其中最常用的是文件和文件映射。

这类对象允许一个线程很容易地向同一进程或其他进程中的另一线程发送信息。

1、演示线程通过文件对象发送数据程序参见实验指导书运行结果(如果运行不成功,则可能的原因是什么?) :阅读和分析程序,请回答问题:1) 程序中启动了多少个单独的读写线程?__________100__________________________________________________________2) 使用了哪个系统API函数来创建线程例程?_________ CreateThread()________________________________3) 文件的读和写操作分别使用了哪个API函数?_______ ReadFile()______ WriteFile()_____________ 每次运行进程时,都可看到程序中的每个线程从前面的线程中读取数据并将数据增加,文件中的数值连续增加。

操作系统实验二并发与调度

操作系统实验二并发与调度

步骤3:在Visual Studio 2019窗口的工具栏中单击“文件”按钮,在解决方案OSLab中新建一个项目,命名为Lab2_1,并在源文件中添加新建项,命名为Lab2_1.cpp,将实验指导书中的代码拷贝至该文件中。

步骤4:单击“生成”菜单中的“编译”命令,系统对Lab2_1.cpp进行编译。

步骤5:编译完成后,单击“生成”菜单中的“生成”命令,建立Lab2_1.exe可执行文件。

操作能否正常进行?如果不行,则可能的原因是什么?由于程序代码是由pdf文件复制出来的,调整缩进与分号等规范后,进一步调整了安全性,如使用sprint_s等,并使用了命名空间std,减少代码冗余,调整过后,程序代码可以调通。

步骤6:在解决方案资源管理器中右键当前项目,并设置为启动项目。

在工具栏单击“调试”-“开始执行(不调试)”按钮,执行Lab2_1.exe程序。

运行结果(分行书写。

如果运行不成功,则可能的原因是什么?):图2-1 程序Lab2_1运行结果1)event created2)child created3)Parent waiting on child.4)child process begining......5)event signaled6)parent received the event signaling from child7)Parent released.这个结果与你期望的一致吗?(从进程并发的角度对结果进行分析)结果与期望一致。

图2-3 程序Lab3_2运行结果2)根据运行输出结果,对照分析Lab2_2程序,可以看出程序运行的流程吗?请简单描述:该程序使用了互斥体CCountUpDown来保护能被同时访问的共享资源。

该程序首先创建了两个进程来访问共享值,并创建了互斥体来访问数值,随后两个进程依次轮流访问数值(访问后改变并释放)。

五、实验结果与分析实验结果与分析见实验步骤与实验过程。

六、实验心得体会通过本次实验,我加深了对计算机线程的理解,并深入理解了互斥体等相关概念。

操作系统实验报告实验二

操作系统实验报告实验二

操作系统实验报告实验二一、实验目的本次操作系统实验二的目的在于深入理解和掌握操作系统中的进程管理和进程调度相关知识,通过实际的编程和实验操作,观察和分析不同进程调度算法的性能和效果,提高对操作系统核心概念的理解和应用能力。

二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Visual Studio 2019作为编程工具。

实验中涉及的编程语言为 C++。

三、实验内容(一)进程创建与控制编写程序实现创建多个进程,并通过进程控制原语(如创建、等待、终止等)对进程进行管理和控制。

(二)进程调度算法实现1、先来先服务(FCFS)调度算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 资源进行执行。

2、短作业优先(SJF)调度算法优先调度执行时间短的进程,以减少平均等待时间。

3、时间片轮转(RR)调度算法将 CPU 时间划分为固定大小的时间片,每个进程在一个时间片内执行,时间片结束后切换到下一个进程。

(三)性能评估指标1、平均等待时间所有进程等待时间的总和除以进程数量。

2、平均周转时间所有进程周转时间的总和除以进程数量。

周转时间为进程从提交到完成的时间间隔。

四、实验步骤(一)进程创建与控制1、定义进程结构体,包含进程 ID、到达时间、执行时间等信息。

2、使用系统调用或库函数创建进程。

3、在父进程中通过等待函数等待子进程结束,并获取子进程的返回状态。

(二)进程调度算法实现1、先来先服务(FCFS)调度算法按照进程到达时间的先后顺序将进程放入就绪队列。

从就绪队列中取出第一个进程进行调度执行。

2、短作业优先(SJF)调度算法计算每个进程的执行时间。

按照执行时间从小到大的顺序将进程放入就绪队列。

从就绪队列中取出执行时间最短的进程进行调度执行。

3、时间片轮转(RR)调度算法将进程按照到达时间先后顺序放入就绪队列。

为每个进程分配一个时间片,当时间片用完后,将进程放入就绪队列尾部,重新调度下一个进程。

操作系统进程调度实验报告

操作系统进程调度实验报告

学生实验报告姓名:年级专业班级学号成绩
【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意
1.三种进程调度算法的执行结果如下。

(1)FCFS算法
(2)高优先权优先调度算法
(3)时间片轮转调度算法
2.以上三个程序能较好地实现进程的三种调度算法。

(1)用数组元素的顺序输入输出能实现进程的FCFS算法。

(2)用优先权的变化规律描述和冒泡法排序能模拟实现优先权调度算法。

(3)通过数组的运算和利用中间数组能实现时间片轮转调度算法。

3. 虽然以上三个程序能较直观的体现进程基本的三种调度算法,但还是存在一些不足。

(1)如在高优先权调度算中,当同时出现多个进程优先权相同的情况时,程序可能对这些不能选择正确的执行顺序。

改进的方法为添加一个判断,当多个进程的优先权相同时,按FCFS算法执行。

即在程序中表现为按数组元素下标的增大顺序排序。

(2)在时间片轮转算法中,不能一次性的输出进程的调度程度,而要通过多次的输入时间片。

改进的方法为把时间片设置为全局变量,在每次循环时都执行一次。

指导教师签名:
20 年月日
【备注。

2023年操作系统作业调度实验报告

2023年操作系统作业调度实验报告

实验二作业调度实验题目1、编写并调试一个单道解决系统的作业等待模拟程序。

作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)的调度算法。

(1 )先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。

(2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。

二.实验目的:本实验规定用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三.实验过程〈一〉单道解决系统作业调度1)单道解决程序作业调度实验的源程序:zuoye.c 执行程序:zu o y e.exe2)实验分析:1、由于在单道批解决系统中,作业一投入运营,它就占有计算机的一切资源直到作业完毕为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的CP U时限等因素。

2、每个作业由一个作业控制块JCB表达,JCB可以包含如下信息:作业名、提交时间、所需的运营时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运营R(Run)和完毕F(Finish)三种状态之一。

每个作业的最初状态else i f (p->n e e d time<min->need t ime) m in=p; p= p ->next;( while (p!=NULL);i f (iden) {i—;/ / pr i n tf ("\nt i m e =%d: \ t no JCB sub mib.. . wait . . . t ime);tim e s++;i f ( times> 10 0) {prin t f("\nru n t ime i s too Ion g . .. error z,) ;g etc h () ; ))e 1 s e{ru n ning(m i n, m) ;//调用running ()函数}} //forf i na 1 (); 〃调用r u nn i ng()函数)voi d fefs (int m)〃先来先服务算法(int i, iden;syst e m ("cl s ");i ni t a 1 ();f or(i=0;i<n;i++)(p= r ea d y; i d en=l;do{if (p-> s tate= = , W* & &p ->reach t i me<=t i mes) i d e n=0:i f (i d e n )p= p -> n ext;}while(p!=NULL&&iden);if (i d on){i——;prin tf(〃\ n没有满足规定的进程,需等待”);t imes++;i f (time s >1 0 0 ) {prin t f ("\n 时间过长");getch () ;})e 1 se{runn i ng(p, m); 〃调用r u nn i n g ()函数))final () ;//调用ru n n i n g ()函数}void muneO{int m;s y s tem (〃 c 1 s〃);p r i n t f (z/\ n\n\t\t *** 火 * ****** * ***** * ***** *** *** * *** * **** ***** **\ t \ t\n ");P rintf ('\t \ t \ t\t 作业调度演示\ n ");pr i ntf( " \t\t^ ***** * * *** * *** * ******** * * **** * ******** * * *** * \t\P r intf(*\n\n\n\t\ t \tl.先来先服务算法.;pr i nt f ("\n\t\ t \ t2.最短作业优先算法.;printfC\n\ t \ t \t3.响应比高者优先算法");prin t f ( ° \0.退出程序.;P rintfC \n\n\t \t\ t \t 选择所要操作:");s c anf (*%d*, &m);sw i tc h (m)(c ase 1:f c f s (m);getchO ;s y stem("c 1 s");mune();brea k ;c a se 2 :sjf (m):getch ();system ( " cis*);mune ();break;case 3 :hr n (m);g e t c h ();sys t em("cls");mune ();br e a k ;case 0:system ("cis");break;d e f a u 1 t :pr intf(〃选择错误,重新选择getchO ;system ("c Is");muneO ;))main ()//主函数(i niz e ();muneO ;)5)调试结果:i.选择操作的界面程课件'计算机操作系统联作系统实验八作业调度\zuoye.exe ,作业调度演示.先来先服务算法.1 .最短企业优先算法.2 .响应居意者优先萱法 4战出程序.选择所要操作:2.输入操作初始信息:c 「E:\课程课件'计算机》3 .先来先服务算法作业调度结果:(调度顺序:a -> b ->c->d->e )输入作业数:5输入作业数:5太人作业名:a7、侬、|到达时间:0要运行的时间:4 必法崎松时间其要运行的时间:3植入作业名:c 作业默认到达时间:2 曲人作批要运行的时间;5 植入作业名:d 伟业默认到达时间:3 曲入作要运行的时间;2 检入作业名:e 伟业默认到达时间;4 输入作业要运行的时间;4作业证在运行,估计其运行情况: 开始运宜时刻:。

操作系统进程调度实验报告

操作系统进程调度实验报告

操作系统进程调度实验报告操作系统进程调度实验报告引言:操作系统是计算机系统中的核心软件之一,负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一,负责决定哪个进程可以获得处理器的使用权,以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法,加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程,掌握进程调度算法的实现方法,深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现,可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中,我们选择了最简单的先来先服务(FCFS)调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度,即先到先服务。

这种调度算法的优点是简单易实现,但缺点是无法适应不同进程的执行时间差异,可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时,我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程,例如:```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中,我们需要按照进程到达的先后顺序进行调度。

具体实现时,可以使用一个队列来保存待调度的进程,并按照到达时间的先后顺序将进程入队。

然后,按照队列中的顺序依次执行进程,直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法,我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标,可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构,包括进程ID、到达时间和执行时间等信息。

《操作系统》实验二

《操作系统》实验二

《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解,通过实际操作,提高对操作系统设计和实现的认知。

通过实验二,我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。

二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。

b.设计一个简单的进程调度算法,如轮转法或优先级调度法。

c.实现进程间的通信机制,如共享内存或消息队列。

2、线程调度a.实现线程的创建、撤销和调度。

b.实现一个简单的线程调度算法,如协同多任务(cooperative multitasking)。

3、内存管理a.设计一个简单的分页内存管理系统。

b.实现内存的分配和回收。

c.实现一个简单的内存保护机制。

4、文件系统a.设计一个简单的文件系统,包括文件的创建、读取、写入和删除。

b.实现文件的存储和检索。

c.实现文件的备份和恢复。

三、实验步骤1、进程管理a.首先,设计一个进程类,包含进程的基本属性(如进程ID、状态、优先级等)和操作方法(如创建、撤销、阻塞、唤醒等)。

b.然后,实现一个进程调度器,根据不同的调度算法对进程进行调度。

可以使用模拟的方法,不需要真实的硬件环境。

c.最后,实现进程间的通信机制,可以通过模拟共享内存或消息队列来实现。

2、线程调度a.首先,设计一个线程类,包含线程的基本属性(如线程ID、状态等)和操作方法(如创建、撤销等)。

b.然后,实现一个线程调度器,根据不同的调度算法对线程进行调度。

同样可以使用模拟的方法。

3、内存管理a.首先,设计一个内存页框类,包含页框的基本属性(如页框号、状态等)和操作方法(如分配、回收等)。

b.然后,实现一个内存管理器,根据不同的内存保护机制对内存进行保护。

可以使用模拟的方法。

4、文件系统a.首先,设计一个文件类,包含文件的基本属性(如文件名、大小等)和操作方法(如创建、读取、写入、删除等)。

b.然后,实现一个文件系统管理器,包括文件的存储和检索功能。

操作系统实验2进程调度 实验报告

操作系统实验2进程调度 实验报告
(1)掌握时间片轮换的进程调度算法;
(2)掌握带优先级的进程调度算法;
(3)选用面向对象的编程方法。
二、实验内容;
(1)用C语言(或其它语言,如Java)实现对N个进程采用动态优先调度算法的调度。
(2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:
进程标识数ID。
进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。
4.可动态添加、删除进程;
5.完成所有进程操作。
五、程序源代码及注释
六、实验结果分析
1、运行结果如下:
2、结果分析
首先,每次从就绪队列中选择最高优先权的进程时,需要计算出最高优先权和次高优先权之间的STARTBLOCK。即最高优先权进程运行多少个时间片后就会进入阻塞队列。每调度一次,就需要更新所有进程的信息,并判断CPUTIME是否等于ALLTIME,如果相等,则进程完成操作,需从就绪队列中删除。如果阻塞队列中进程的BLOCKTIME为0时,还需要将其转移到就绪队列中。
(5)用户可以干预进程的运行状态,程序应该设置可以让用户中断的入口,并可以通过以下命令查看,修改,终止进程。
A)create随机创建进程,进程的优先级与所需要的时间片随机决定;
B)ps查看当前进程状态
C)sleep命令将进程挂起
D)kill命令杀死进程
E)quit命令退出
(5)分析程序运行的结果,谈一下自己的认识。
三、实验原理;
无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外,系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。
根据进程的五个特征:(1)动态性;(2)并发性;(3)异步性;(4)独立性;(5)结构性及三种基本状态的转换,了解各进程对资源的共享和竞争。进程并发执行时,由于资源共享,带来各进程之间的相互制约。为了反映这些制约关系和资源共享关系,在创建一个进程时,应首先创建其PCB,然后才能根据PCB中信息对进程实施有效的管理和控制。当一个进程完成其功能之后,系统则最后释放PCB,进程也随之消亡。

重庆大学操作系统实验二

重庆大学操作系统实验二

重庆大学学生实验报告实验课程名称操作系统原理开课实验室重庆大学DS1501学院软件工程年级2013 专业班学生姓名学号开课时间2015 至2016 学年第一学期重庆大学软件学院制操作系统原理》实验报告实验目的(软件需求文档)掌握线程的创建掌握线程的调度静态优先级调度动态优先级调度二、实验原理(软件设计文档)系统调用接口,线程相关函数:Step1:定义线程函数voidtsk_foo(void *pv) {n“ , task_getid());task_exit(0);}Step2:申请用户栈unsigned char *stack_foo;stack_foo = (unsigned char *)malloc(1024*1024);free 释放掉!线程退出后,才能把用户栈用Step3:创建线程int tid_foo;tid_foo = task_create(stack_foo+1024*1024, tsk_foo, (void *)0);三、使用仪器、材料(软硬件开发环境) Notepad++ expenv四、实验步骤(实现的过程)随机生成3 组非负整数列表,创建3 个线程,分别用3 种不同的排序算法(插入,冒泡,选择) 对列表进行排序三线程:void tsk_foo_line1(void * pv){int m;int i;int arry[50]; srand(time(NULL));for (i =0; i<50; i++){ m= random() % 200; if (m<0) { m=0- m;} draw(i * 10, 0, 0 + m); arry[i] = m;}sort_m(arry, 50, 0); task_exit(0);}void tsk_foo_line2(void * pv){int m;int i;int arry[50];srand(time(NULL));for (i =0; i<50; i++){m= random() % 200;if (m<0) { m=0- m;} draw(i * 10, 345, 345 +m); arry[i] = m;}sort_x(arry, 50, 345); task_exit(0);}void tsk_foo_line3(void * pv){int m;int i;int arry[50];srand(time(NULL));for (i =0; i<50; i++){ m= random() % 200; if (m<0) { m=0- m;} draw(i * 10, 690, 690 +m); arry[i] = m;}sort_c(arry , 50, 690);task exit(0);}void draw(int x, int y1, int y2){int i;for (i =y1; i<y2; i++)setPixel(i , x, RGB(255, 255, 255)); }void resetBK(int x, int y1, int y2){ int i;for (i =y1; i<y2; i++) setPixel(i , x, RGB(0, 0, 0));} 三排序:冒泡void sort_m(int * arry, int n,int l){int i, j, tem ; int t = 500 / n;for (i =0; i<n; i++)for (j=0;j<n-i- 1; j++){if (*( arry + j)>*(arry +j +1)){ resetBK(j* t, l, l + *(arry +j)); resetBK(j* t +t, l, l +*( arry + j + 1)); tem = *( arry + j);*( arry + j) = *(arry +j+1); *( arry + j + 1) = tem ; draw (j * t , l, l + *( arry +j)); draw(j*t +t,l,l + *( arry + j+ 1));}}void sort_c(int * arry, int n, int l){ int i, j, key;int t =500/ n;for (j=n- 2; j >= 0; j--){ key = *( arry +j);i =j +1; resetBK(j * t , l, l+key); while (i<n&& *( arry + i )<key){ *( arry +i -1) = *( arry +i); draw(i*t -t,l,l+*(arry+i- 1)); i =i +1;}*( arry +i - 1) = key; draw(i* t -t, l, l + key);}} 选择void sort_x(int* arry, int n, int l){int i=0, j=0, lowindex = 0;int t =500/ n;for (i =0; i<n; i ++){lowindex =i;for (j =n -1; j>i; j--) if (arry[j] < arry[lowindex ])lowindex = j;if (lowindex != i){resetBK(i*t , l, l + *(arry +i)); resetBK(lowindex* t, l,l + *(arry + lowindex )); int temp = arry[ i];arry [i] = arry[ lowindex];arry [lowindex ] = temp ; draw (i * t , l, l + *( arry +i));draw(lowindex* t, l, l + *(arry + lowindex ));}}}线程控制块tcb 中增加nice 属性,在函数sys_task_create 中初始化nice=0 /*系统调用getpriority 的执行函数获取当前线程的优先级*/int sys_getpriority (int tid){if (tid ==0) return g_task_running->nice+NZERO;// 获取当前线程的nice值uint32_t flags; struct tcb *tsk;save flags cli(flags);tsk = get_task(tid ); restore_flags(flags);return tsk->nice+NZERO; // 获取线程的nice 值}/* 系统调用setpriority 的执行函数调整当前线程的优先级线程控制块tcb 中增加estcpu 属性,在函数sys_task_create 中初始化estcpu=0; 增加priority 属性,在函数sys_task_create 中初始化priority=0; 中增加全局变量g_load_avg:表示系统的平均负荷用浮点(float-point) 表示g_load_avg 和estcpu:精度高,效率低动态调度schedule:void schedule(){struct tcb * select=g_task_head;struct tcb * my_select=g_task_running ; while (select != NULL){select->priority =127- fixedpt_toint (fixedpt_div(select->estcpu, fixedpt_fromint (4))) - select->nice * 2; // 计算所有线程的priorityselect = select->next ;}// 动态优先级select = g_task_head; while(select!=NULL){if((select->tid != 0) &&(select->state ==TASK STATE READ))Y{if(my_select->priority <select->priority )my_select=select;// 选择等待队列里的线程优先级高的elseif(my select->tid==0){my_select=select;} select=select->next;}if (my select==g task running) { if(my_select->state == TASK_STATE_READ) Y return ;my_select = task0;}printk ("0x%d -> 0x%d\r\n" , (g_task_running == NULL) -1: g_task_running->tid , select->tid);g_resched = 0;switch_to (my_select);}中添加如下g_task_running->estcpu=fixedpt_add(g_task_running->estcpu,FIXEDPT_ON)E;//计算线程使用CPU时间estcpuif(g timer ticks %HZ==0){// 每隔一秒计算一次int nready=0; // 表示处于就绪状态的线程个数struct tcb *my select=g task head;int nice;//g task running->nice;//my_select=g_task_head;fixedpt ratio ;while(my select!=NULL){if (my select->state==TASK STATE REA)DnYready++ nice=my select->nice;ratio = fixedpt_mul (FIXEDPT_TWO, g_load_avg);// 每秒钟为所有线程运行、就绪和等待)更新一次ratio = fixedpt_div (ratio , fixedpt_add (ratio , FIXEDPT_ON)E);my_select->estcpu = fixedpt_add (fixedpt_mul (ratio ,my_select->estcpu),fixedpt_fromint (nice))my_select=my_select->next;fixedpt r59 60 = fixedpt div (fixedpt fromint (59), fixedpt fromint (60));// 计算系统的平均负荷g load avgfixedpt r01 60 = fixedpt div (FIXEDPT ON,Efixedpt fromint (60)) g load avg= fixedpt add (fixedpt mul (r59 60, g load avg),fixedpt_mul (r01_60, fixedpt_fromint (nready)));主函数:int mode = 0x0118;initGraphics (mode);int y =0;for (y=0;y<; y++){setPixel/ 3,y, RGB(0, 125, 125)); setPixel/ 3 * 2, y, RGB(0, 125, 125));}五、实验结果及分析(实现的效果,包括屏幕截图、系统总体运行情况和测试情况等)静态优先级:Llxh心必ew动态优先级:。

《操作系统》实验报告(2)

《操作系统》实验报告(2)

《操作系统》实验报告(2)操作系统实验报告(2)1:实验目的本次实验旨在深入理解操作系统的进程管理和内存管理,并通过编写相应的实验程序加深对操作系统的原理和实践的理解。

2:实验环境操作系统:Windows 10开发工具:Visual Studio Code编程语言:C/C++3:实验内容3.1 进程管理3.1.1 进程的创建在操作系统中,进程创建是指从一个已经存在的进程派生出一个新进程的过程。

在本次实验中,我们使用了fork()系统调用来创建新进程,详细的创建流程如下:1:父进程调用fork()系统调用,新进程被创建并成为父进程的子进程。

2:子进程从fork()调用后开始执行,继承父进程的资源和代码。

3:父进程和子进程分别根据fork()的返回值判断当前进程是父进程还是子进程,并分别执行各自的逻辑。

3.1.2 进程的调度进程调度是操作系统的重要功能之一,旨在合理地分配 CPU 时间和资源。

在本次实验中,我们使用了简单的时间片轮转调度算法,详细的调度流程如下:1:操作系统根据进程的优先级和时间片大小进行调度,选择就绪队列中的下一个进程执行。

2:进程被调度执行,执行完当前时间片后,被放入就绪队列末尾,让出 CPU。

3:操作系统根据调度算法从就绪队列中选择下一个进程执行,重复上述步骤。

3.2 内存管理3.2.1 空闲内存的管理在操作系统中,内存管理是指对内存的合理分配和回收。

在本次实验中,我们使用了内存位图算法进行空闲内存的管理,详细的管理流程如下:1:操作系统初始化时,建立起一张内存位图,用于表示内存的分配情况。

2:对于每个请求分配内存的进程,操作系统根据位图找到合适的空闲内存块,并分配给进程使用。

3:进程释放内存时,操作系统更新内存位图,标记对应的内存块为空闲。

3.2.2 页面置换算法页面置换算法是解决物理内存不足时进行页面调度的一种重要策略。

在本次实验中,我们使用了最简单的FIFO算法进行页面置换,详细的置换流程如下:1:当物理内存不足时,操作系统根据FIFO算法,选择最早入内存的页面进行置换。

操作系统的实验二

操作系统的实验二

操作系统的实验二在学习操作系统的过程中,实验是加深理解和掌握知识的重要环节。

本次的操作系统实验二,让我对操作系统的原理和功能有了更深入的认识。

实验二的主要目标是探究进程管理和线程调度的机制。

进程和线程是操作系统中非常关键的概念,它们的有效管理和调度直接影响着系统的性能和资源利用效率。

在实验开始之前,我们需要对相关的理论知识有清晰的了解。

进程是程序在一个数据集合上的一次执行过程,它具有动态性、并发性、独立性和异步性等特征。

而线程则是进程中的一个执行单元,线程之间可以共享进程的资源,从而减少系统开销。

实验中,我们使用了特定的操作系统环境和工具来进行模拟和观察。

通过设置不同的进程和线程参数,如优先级、时间片等,来观察它们在系统中的执行情况和资源分配情况。

在进程管理部分,我们首先创建了多个进程,并为它们分配不同的资源。

例如,为某些进程分配更多的内存空间,为另一些进程分配更多的CPU 时间。

然后,我们观察这些进程的执行顺序和资源占用情况。

通过实验,我们发现,优先级较高的进程往往能够优先获得系统资源,从而更快地完成执行。

但是,如果高优先级进程一直占用资源,可能会导致低优先级进程长时间得不到执行,出现“饥饿”现象。

为了避免这种情况,操作系统通常会采用一些公平性策略,如轮转调度、多级反馈队列调度等,来确保各个进程都有机会获得资源执行。

线程调度的实验则更加复杂一些。

线程之间共享进程的资源,这使得它们的调度更加灵活和高效。

我们创建了多个线程,并为它们设置不同的优先级和执行时间。

在实验中,我们发现,当多个线程同时竞争资源时,操作系统会根据它们的优先级和等待时间来进行调度。

优先级高的线程会优先执行,但如果优先级低的线程等待时间过长,操作系统也会适时地将其调度执行,以保证系统的公平性和响应性。

此外,我们还研究了进程和线程之间的通信方式。

进程之间的通信通常需要通过共享内存、消息队列、管道等方式来实现,而线程之间由于共享进程的资源,可以直接通过共享变量等方式进行通信。

操作系统实验二实验报告

操作系统实验二实验报告

实验二处理机管理(4学时)实验目的正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏,在操作系统中调度的实质是一种资源分配,调度算法是指根据系统的资源分配策略规定的资源分配算法,对不同的系统和系统目标,应采用不的调度算法。

(或)在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。

也就是说能运行的进程数远远大于处理机个数。

为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择一进程占用处理机。

通过本实验,加深对处理机调度的理解。

实验内容处理机管理是操作系统中非常重要的部分。

为深入理解进程管理部分的功能,设计几个调度算法,模拟实现处理机的调度。

编程模拟FCFS调度算法、SJ(P)F算法、高优先权调度算法、基于时间片轮转调度算法。

注:“基于时间片轮转调度算法模拟”为必作,其余选做。

实验准备及实验设备计算机,Tc2.0实验步骤正确理解各调度算法的基本思想;根据各调度算法定义PCB(模拟)的格式:FCFS算法和基于时间片轮转调度算法,可设PCB的格式为:高优先权调度算法可设PC为:在正确理解各调度算的基础上编写出相应的程序。

在所设计的调度程序中,针对不同算法应包含显示和打印语句,以便显示或打印程序运行的初值和运行结果:各PCB的初始状态,选中运行进程的名称、运行后各PCB状态以及每次调度时,就绪队列的进程排列顺序(针对不同算法有所不同)。

(源程序)实验结果(运行所编的模拟调度程序,所得结果略)FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。

SJ(P)F算法不利于长作业(进程),该算法未考虑作业的紧迫程序,因而不能保证紧迫性作业(进程)会被及时处理,并且由于作业(进程)的长短是用户所提供的估计执行时间而定的,致使该算法不一定能真正做到短作业优先调度。

高优先权(分动态和静态优先权)调度算法即照顾了短作业,又考虑了作业到达的紧迫性。

对于静态优先权法,系统开销小,但不够精确,可能出现优先权低的作业(进程)长期没有被调度的情况;对于动态优先权(高响应比优先)法,它既照顾了短作业,又考虑了作业的先后次序,不会使长作业长期得不到服务,但每要进行调度之前,都须做响应比的计算,会增加系统开销。

操作系统实验二进程调度

操作系统实验二进程调度

操作系统实验二进程调度摘要:进程调度是操作系统中重要的功能之一,可以决定进程的优先级和执行顺序。

本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。

一、概念介绍进程调度是操作系统中的一项重要功能,用于决定哪个进程能够在处理器上运行。

在操作系统中存在多个进程需要同时运行,而处理器资源有限,因此需要通过进程调度来合理地安排进程的执行顺序,提高系统的效率。

进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。

常见的调度策略包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转、优先级调度等。

二、调度算法介绍1.先来先服务(FCFS)先来先服务(FCFS)是最简单的调度算法,按照进程到达的顺序进行调度,先到达的进程先执行。

FCFS算法不考虑进程的优先级和执行时间,容易导致平均等待时间长。

2.最短作业优先(SJF)最短作业优先(SJF)调度算法按照进程所需的CPU时间进行排序,优先调度所需时间最短的进程。

SJF算法可以减少平均等待时间,但可能会导致长作业等待时间过长。

3.时间片轮转时间片轮转是一种抢占式调度策略,将处理器的使用权分割为若干个时间片,每个进程在一个时间片内运行,如果时间片用完仍未运行完,则将该进程放到队列的末尾,并让下一个进程运行。

时间片轮转算法保证了公平性和响应时间,但可能会导致上下文切换次数过多。

4.优先级调度优先级调度是根据进程的优先级进行调度,优先级高的进程先执行。

优先级可以根据进程类型、实时性等因素确定,不同的操作系统可能有不同的优先级范围和策略。

三、实验步骤1.定义进程结构:定义进程结构体,包含进程ID、进程状态、优先级、执行时间等信息。

2.初始化进程队列:将所有进程按照到达的先后顺序加入到进程队列中。

3.实现调度算法:根据不同的调度算法,实现相应的进程调度算法代码。

可以使用循环遍历进程队列,并根据不同的调度策略决定下一个要执行的进程。

4.执行进程调度:在每个时间片结束后,根据调度算法选取下一个要执行的进程,并更新进程的状态和执行时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
}
线程控制块tcb中增加nice属性,在函数sys_task_create中初始化nice=0
/*
系统调用getpriority的执行函数
获取当前线程的优先级
*/
intsys_getpriority(inttid)
{
if(tid==0)returng_task_running->nice+NZERO;//获取当前线程的nice值
inti=0,j=0,lowindex=0;
intt=500/n;
for(i=0;i<n;i++){
lowindex=i;
for(j=n-1;j>i;j--)
if(arry[j]<arry[lowindex])
lowindex=j;
if(lowindex!=i)
{
resetBK(i*t,l,l+*(arry+i));
m=random()%200;
if(m<0){m=0-m;}
draw(i*10,345,345+m);
arry[i]=m;
}
sort_x(arry,50,345);
task_exit(0);
}
voidtsk_foo_line3(void*pv)
{
intm;
inti;
intarry[50];
srand(time(NULL));
{
printf("This is task foo with tid=%d\r\n“, task_getid());
task_exit(0);
}
•Step2:申请用户栈
unsigned char *stack_foo;
stack_foo = (unsigned char *)malloc(1024*1024);
–线程退出后,才能把用户栈用free释放掉!
•Step3:创建线程
int tid_foo;
tid_foo = task_create(stack_foo+1024*1024, tsk_foo, (void *)0);
三、使用仪器、材料(软硬件开发环境)
Notepad++
expenv
四、实验步骤(实现的过程)
uint32_tflags;structtcb*tsk;
save_flags_cli(flags);
tsk=get_task(tid);
restore_flags(flags);
软件学院
年级、专业、班
姓名
成绩
课程
名称
操作系统原理
实验项目
名 称
线程及其调度
指导教师
教师评语
教师签名:
年 月 日
一、实验目的(软件需求文档)
掌握线程的创建
掌握线程的调度
a)静态优先级调度
b)动态优先级调度
二、实验原理(软件设计文档)
系统调用接口,线程相关函数:
•Step1:定义线程函数
void tsk_foo(void *pv)
重 庆 大 学
学 生 实 验 报 告
实验课程名称操作系统原理
开课实验室重庆大学DS1501
学 院软件工程年级2013专业班
学 生 姓 名学 号
开 课 时 间2015至2016学年第一学期
总 成 绩
教师签名
洪明坚
重庆大学软件 学院制
《操作系统原理》实验报告
开课实验室:DS15012016年1月6日
学院
if(m<0){m=0-m;}
draw(i*10,0,0+m);
arry[i]=m;
}
sort_m(arry,50,0);
task_exit(0);
}
voidtsk_foo_line2(void*pv)
{
intm;
inti;
intarry[50];
srand(time(NULL));
for(i=0;i<50;i++){
随机生成3组非负整数列表,创建3个线程,分别用3种不同的排序算法(插入,冒泡,选择)对列表进行排序
三线程:
voidtsk_foo_line1(void*pv)
{
intm;
inti;
intarry[50];
srand(time(NULL));
for(i=0;i<50;i++){
m=random()%200;
for(i=0;i<50;i++){
m=random()%200;
if(m<0){m=0-m;}
draw(i*10,690,690+m);
arry[i]=m;
}
sort_c(arry,50,690);
task_exit(0);
}
voiddraw(intx,inty1,inty2){
inti;
for(i=y1;i<y2;i++)
*(arry+j+1)=tem;
draw(j*t,l,l+*(arry+j));
draw(j*t+t,l,l+*(arry+j+1));
}
}
}
插入
voidsort_c(int*arry,intn,intl){
inti,j,key;
intt=500/n;
for(j=n-2;j>=0;j--){
key=*(arry+j);i=j+1;
setPixel(i,x,RGB(255,255,255));
}
voidresetBK(intx,inty1,inty2){
inti;
for(i=y1;i<y2;i++)
setPixel(i,x,RGB(0,0,0));
}
三排序:
冒泡
voidsort_m(int*arry,intn,intl){
inti,j,tem;
intt=500/n;
for(i=0;i<n;i++)
for(j=0;j<n-i-1;j++){
if(*(arry+j)>*(arry+j+1)){
resetBK(j*t,l,l+*(arry+j));
resetBK(j*t+t,l,l+*(arry+j+1));
tem=*(arry+j);
*(arry+j)=*(arry+j+1);
resetBK(j*t,l,l+key);
while(i<n&&*(arry+i)<key){
*(arryHale Waihona Puke i-1)=*(arry+i);
draw(i*t-t,l,l+*(arry+i-1));
i=i+1;
}
*(arry+i-1)=key;
draw(i*t-t,l,l+key);
}
}
选择
voidsort_x(int*arry,intn,intl){
resetBK(lowindex*t,l,l+*(arry+lowindex));
inttemp=arry[i];
arry[i]=arry[lowindex];
arry[lowindex]=temp;
draw(i*t,l,l+*(arry+i));
draw(lowindex*t,l,l+*(arry+lowindex));
相关文档
最新文档