普通本科实验报告模板操作系统实验二
操作系统实验二实验报告

操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术,包括进程的创建、执行、同步和通信。
通过实际编程和实验操作,提高对操作系统原理的认识,培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10,编程环境为 Visual Studio 2019。
三、实验内容及步骤(一)进程创建实验1、首先,创建一个新的 C++项目。
2、在项目中,使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束,并获取其退出代码。
(二)进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区,当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理,当缓冲区为空时等待。
(三)进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道,父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据,子进程从管道读取数据并进行处理。
四、实验结果及分析(一)进程创建实验结果成功创建了新的进程,并能够获取到其退出代码。
通过观察进程的创建和执行过程,加深了对进程概念的理解。
(二)进程同步实验结果通过使用信号量,生产者和消费者进程能够正确地进行同步,避免了缓冲区的溢出和数据的丢失。
分析结果表明,信号量机制有效地解决了进程之间的资源竞争和协调问题。
(三)进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递,验证了管道通信的有效性。
五、遇到的问题及解决方法(一)在进程创建实验中,遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试,最终正确设置了参数,成功创建了进程。
(二)在进程同步实验中,出现了信号量使用不当导致死锁的情况。
操作系统lab2实验报告

操作系统lab2实验报告实验目的:本实验的目的是通过设计和实现一个简单的操作系统内核,加深对操作系统基本概念和原理的理解。
具体实验内容包括进程管理、内存管理和文件系统的设计与实现。
实验环境:1.操作系统:Linux2.编程语言:C语言一、实验背景1.1 操作系统简介操作系统是计算机系统中的一个重要组成部分,负责管理和控制计算机的各种资源,提供用户和应用程序的接口,以及协调和调度各种任务的执行。
1.2 实验目标本实验的主要目标是设计和实现一个简单的操作系统内核,包括进程管理、内存管理和文件系统等功能。
二、实验内容2.1 进程管理①进程创建描述进程创建的过程和相关数据结构,包括创建新进程的系统调用、进程控制块等。
②进程调度描述进程调度的算法和实现方式,包括进程调度队列、调度算法等。
③进程同步与通信描述进程同步和通信的机制和方法,包括信号量、互斥锁、条件变量等。
2.2 内存管理①内存分配描述内存分配的算法和实现方式,包括连续内存分配、非连续内存分配等。
②页面置换描述页面置换的算法和实现方式,包括最优页面置换算法、先进先出页面置换算法等。
2.3 文件系统①文件操作描述文件操作的系统调用和相关数据结构,包括文件打开、读写、关闭等。
②文件系统结构描述文件系统的组织结构和实现方式,包括超级块、索引节点、块位图等。
三、实验步骤3.1 环境搭建搭建实验环境,包括安装Linux操作系统、编译器等。
3.2 进程管理实现根据设计要求,实现进程创建、调度、同步与通信等功能。
3.3 内存管理实现根据设计要求,实现内存分配、页面置换等功能。
3.4 文件系统实现根据设计要求,实现文件操作和文件系统结构。
3.5 测试与调试编写测试用例,对实现的操作系统内核进行测试和调试,并记录实验结果。
四、实验结果分析分析测试结果,评估实验过程中遇到的问题和解决方法,总结操作系统内核的性能和功能特点。
五、实验总结对实验过程中的收获和经验进行总结,提出改进和优化的建议。
操作系统实习二报告

实验二主存储器空间的分配和回收一、实验题目:模拟在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。
二、实验目的:主存的分配和回收的实现与主存储器的管理方式有关,通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验内容:一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。
四、程序中使用的数据结构及符号说明:五、程序流程图:六、程序源代码:#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n)/*尾插法创建带头结点的单链表*/{linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("\n请分别输入页表的页号及块号(-1表示空):\n");printf("\n页号| 块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void init(int g[100][100],int N)/*初始化位示图,将值全置为零,0表示空闲状态*/{int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0; //全置为零}}g[N+1][0]=N*N; //在数组最后一个数的后面设置一个空间用来存放剩余空闲块数}linklist Init(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=1;g[N+1][0]--;p=p->next;}}return head;}printStr(int g[100][100],int N)/*打印位示图*/{int i,j;printf("\n此时位示图为:\n");printf("\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}printf("\n");}void print(linklist head)/*输出带头结点的单链表*/{linklist p;p=head->next;printf("\n该页表为:\n");printf("\n");printf("\n 页号| 块号\n");while(p){printf("%11d%7d\n",p->pageNum,p->blockNum);p=p->next;}printf("\n");}linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j; //将对应块号记录到页表g[i][j]=1; //将块置1,表示已被占用g[N+1][0]--; //剩余空闲块减1break; //跳出循环,进行下一个页的分配}}break; //跳出循环}p=p->next; //下一个页进行分配}return head;}}linklist Recy(linklist head,int g[100][100],int n,int N)/*回收已经完成的页*/ {int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n) //找出要回收的页号{p=p->next;}if(p) //找到{i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0; //将该块置0,表空闲状态g[N+1][0]++;p->blockNum=-1; //页表中对应的块号为空,置成-1}return head;}void main(){int m,n,N;int x,y,a,b,t;int graph[100][100];linklist head,Head;printf("\n*****分页式存储管理分配及回收算法*****\n");printf("\n请输入位示图字长:");scanf("%d",&N);printf("\n请输入已占用内存作业的页数:");scanf("%d",&m);head=creatlinklist(m);init(graph,N);head=Init(head,graph,m,N);printStr(graph,N);printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n\n现在进行作业分配:\n");printf("\n请输入需要分配的作业的页数:");scanf("%d",&n);Head=creatlinklist(n);Head=Dis(Head,graph,n,N);print(Head);printStr(graph,N);printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n\n您是否想回收已完成的页,“是”请按1,“否”请按0:");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号:");scanf("%d %d %d %d",&y,&a,&b,&t);head=Recy(head,graph,y,N);head=Recy(head,graph,a,N);head=Recy(head,graph,b,N);head=Recy(head,graph,t,N);printStr(graph,N);}printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n");}七、运行结果:实习小结:本次实验是自己花了很多的时间去琢磨去尝试才完成的,虽然还不是很完美,但是在设计的过程中自己在对编程方面的逻辑思维得到了很好的锻炼。
操作系统实验报告实验二

操作系统实验报告实验二一、实验目的本次操作系统实验二的目的在于深入理解和掌握操作系统中的进程管理和进程调度相关知识,通过实际的编程和实验操作,观察和分析不同进程调度算法的性能和效果,提高对操作系统核心概念的理解和应用能力。
二、实验环境本次实验在 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)调度算法将进程按照到达时间先后顺序放入就绪队列。
为每个进程分配一个时间片,当时间片用完后,将进程放入就绪队列尾部,重新调度下一个进程。
操作系统Lab2实验报告

深入学习 操作系统的原理和实 现细节,包括进程通 信、死锁处理、虚拟 化技术等。
实践应用
希望将所学的操作系 统知识应用到实际项 目中,提高自己的实 践能力。
持续学习
随着技术的不断发展 ,操作系统也在不断 更新和进步,需要保 持持续学习的态度。
探索新领域
对于新兴的操作系统 领域,如云操作系统 、物联网操作系统等 ,也希望有所涉猎和 探索。
学生将了解操作系统内核的组成和功能,以及操作系统如何通过内核 实现各种基本功能。
学生将通过实验深入了解操作系统的内部实现细节,提高自己对操作 系统设计和实现的认知水平。
02
实验内容
进程管理实验
总结词
理解进程状态及其转换、进程控制块PCB的组成、进程调度算法。
详细描述
通过实验,我们深入了解了进程的概念、状态及其转换。进程控制块PCB的组成,包括进程标 识符、进程状态、优先级、CPU寄存器内容等信息。此外,我们还学习了进程调度算法,如先 来先服务、最短作业优先、优先级调度等,并进行了模拟实验。
THANKS
感谢观看
操作系统Lab2实验 报告
汇报人:
202X-01-08
目录
• 实验目的 • 实验内容 • 实验结果与分析 • 问题与改进建议 • 总结与展望
01
实验目的
理解操作系统的基本概念
01
掌握核心概念
02
操作系统是计算机系统的核心软件,负责管理计算机硬件和软件资源 ,为用户提供便利的操作界面和高效的服务。
03
操作系统具有并发性、虚拟性、异步性和随机性的特点,这些特点决 定了操作系统在计算机系统中的重要地位和作用。
04
操作系统的基本功能包括进程管理、内存管理、文件管理和设备管理 ,这些功能是操作系统实现其核心目标的基础。
操作系统实验报告(2)

计算机实验报告(2)操作系统部分一、基本要求和内容1.了解操作系统的基本功能.2.认识WINDOWS桌面的各部分组成,掌握基本的桌面操作.3.掌握各种基本操作对象的操作方法.4.学会使用WINDOWS帮助.5.了解基本的DOS命令和基本的命令行操作方法.6.熟练掌握文件操作方法.7.掌握对图标的操作方法(移动/拖曳/单击/双击/右击等等).8.熟悉资源管理器窗口和”我的电脑”(“计算机”)窗口.9.掌握启动控制面板的方法,了解控制面板的主要功能,掌握使用控制面板对软硬件进行设置的方法。
10.掌握“运行”对话框的使用方法。
11.了解“任务管理器”的简单使用方法。
12.熟悉“画图”“记事本”“计算器”“写字板”等常用应用程序。
13.开始POWERPOINT的基本使用.二、通过上机实验解决下列问题1. CTRL+ALT+DEL 组合键的功能是:打开【任务管理器】窗口2.全角和半角的区别是:半角是一个字符,全角是两个字符3. CTRL+A组合键的功能是:全部选中CTRL+C组合键的功能是:复制CTRL+V组合键的功能是:粘贴CTRL+X组合键的功能是:剪切CTRL+Z组合键的功能是: 撤销ALT+PRINTSCREEN组合键的功能是:复制当前窗口、对话框或其他对象到剪贴板中任务栏隐藏时通过什么组合键可以看到任务栏:Ctrl+Alt+Del进行窗口切换的组合键是:ALT+Tab4.“画图”应用程序默认保存文件类型是:*.png“记事本”应用程序默认保存文件类型是: *.txt.DOC是什么文件类型Word文档.EXE是什么文件类型可执行文件(程序文件)5.鼠标的基本操作方法包括:指向、单击、双击和拖动鼠标指针附近有漏沙钟表示当前的状态是: 沙漏是等待,因为程序先是从硬盘上读取,然后再到内存,芯片在其期间进行运算,再没真正的打开程序时,系统认为它没正真的启动6.资源管理器左下角窗格(即”文件夹”窗口)显示的是:系统中的所有资源以分层树型的结构显示出来7.一般情况下,对文件进行重命名时,不应该修改文件的扩展名,因为: 如果修改了后缀名则会导致文件属性更改,文件无法打开8.文件的属性主要包括哪些:“只读”、“存档”、“隐藏”9.选择多个连续的文件可以采用哪些方法:使用鼠标先选定第一个文件或文件夹,然后按住Shift键,用鼠标单击最后一个文件或文件夹,这样在第一个对象和最后一个对象之间的所有文件或文件夹将全部被选中,包括第一个和最后一个文件或文件夹。
操作系统第二次实验报告

semctl(semid,2,IPC_RMID,0);
semctl(semid,3,IPC_RMID,0);
gettimeofday(&_end,NULL);
exe_time = ((float)(__sec - __sec)*1000000+(float)(__usec - __usec))/1000000;
2)利用Linux操作系统提供的信号量工具实现进程间的同步;
3)掌握对共享内存的相关操作;
4)基于生产者-消费者同步的原理实现双缓冲区的誊抄。
二
任意选择一个文本文件,采用并发进程实现文件誊抄,将其复制为另一个文件。
创建get、copy、put三个进程共用两个缓冲区s、t。get进程负责不断地把原始文件内容送入缓冲区s中,copy进程负责从缓冲区s中取出上述内容复制到缓冲区t中,而put进程负责把上述内容从缓冲区t中取出复制到目标文件中,用p、v操作实现这三个进程之间的同步。
}
int V(int semid, int semnum) {
struct sembuf sops = {semnum, +1, SEM_UNDO};
return (semop(semid, &sops, 1));
}
int main()
{
//定义共享缓冲区,获得一个共享内存的标志,新建内存为1KB
int readbuf_id=shmget(231,CACHE_LENGTH,IPC_CREAT|0666);
}
}
//put_porcess
if((put_id=fork())==0){
if((fout=fopen("./put.txt","wb"))==NULL)
《操作系统》实验二

《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解,通过实际操作,提高对操作系统设计和实现的认知。
通过实验二,我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容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.然后,实现一个文件系统管理器,包括文件的存储和检索功能。
操作系统(二)实验报告

Last access:WedOct1915:25:442005
Last modify inode:Wed Oct1915:25:442005
5.再来一个更有趣的实验。修改父进程创建子进程的程序,用显示程序段、数据段地址的方法,说明子进程继承父进程的所有资源。再用父进程创建子进程,子进程调用其它程序的方法进一步证明子进程执行其它程序时,程序段发生的变化。
if(argc-i>1) printf("\n");
}
return ret;
}
运行结果:
[stud028@localhost stud028]$ ./pro41.o pro41.c
File:a.c
On device(major/minor):31,inode number:884266
Size:12 Type: 0100000 Permission:00664
return 1;
}
printf("\nFile Nhomakorabea%s\n",file);
printf("On device(major/minor):%d %d,inode number:%ld\n",
major(buf.st_dev),minor(buf.st_dev),buf.st_ino);
printf("Size:%ld\t Type: %07o\t Permission:%05o\n",buf.st_size,
【提示】这个实验可参考例程3中“父进程创建子进程,子进程调用其他程序的例”以及下面例程10两个程序。设法在子进程运行的程序中显示程序段、数据段地址,以此说明:开始时子进程继承了父进程的资源,一旦子进程运行了其他程序,就用该进程替换从父进程处继承的程序段和数据段。
操作系统实验

操作系统实验报告(一)Linux基本操作与编程(验证性 2学时)1、实验目(de):1)熟悉Linux操作系统(de)环境和使用.2)了解LINUX系统(de)安装过程.(注:表示可选择)3)掌握Linux环境下(de)命令操作.2、实验内容:(1)完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求:结果以屏幕截图表示).1)运行pwd命令,确定你当前(de)工作目录.2)利用以下命令显示当前工作目录(de)内容: ls –l3)运行以下命令: ls –al4)使用mkdir命令建立一个子目录subdir.5)使用cd命令,将工作目录改到根目录(/)上.6)使用ls-l命令列出/dev(de)内容.7)使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8)使用命令cd ../..,你将工作目录移到什么地方(2)在LINUX下查看你(de)文件.1)利用cd命令,将工作目录改到你(de)主目录上.2)将工作目录改到你(de)子目录subdir,然后运行命令: date > file1 将当前日期和时间存放到新建文件file1中.3)使用cat命令查看file1文件(de)内容.4)利用man命令显示date命令(de)用法: man date5)将date命令(de)用法附加到文件file1(de)后面:man date >> file16)利用cat命令显示文件file1(de)内容.7)利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8)利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9)利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10)用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.(3)编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤:1)在文本编辑器中,编写C程序如下:include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下:./a(4)编写一个程序:显示信息“Time for Play”,并能在后台运行一段时间(自定义)后,弹出信息提醒用户.要求记录所使用(de)命令及结果.(提示:使用sleep(s)函数)3、实验结果分析:(对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题)(1)进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性(2)在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行;正在运行(de)命令,使用Ctrl+z ,就挂起; jobs命令,可以现实后台,包括挂起(de)命令;使用 bg %作业号就可以把挂起(de)命令在后台执行;使用 fg %作业号就可以把后台命令调到前台(3)你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013(4)你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结:你对本次实验有什么体会或看法.操作系统实验报告(二)文件访问权限设置与输入输出重定向(2学时)一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限:在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作:chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限:chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行;其他用户和所属组用户只有读和执行(de)权限:chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道(1) 输出重定向用ls命令显示当前目录中(de)文件列表:ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中:ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令:cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向:ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别:cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.(2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤:在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论(根据实验结果回答下列问题)1. 文件(de)权限如下:-rw-r—r-- 1 root root 19274 Jul 14 11:00回答:-rw-r—r-- (de)含义是什么答:是LINUX/FTP(de)简易权限表示法:对应于本用户-所在组-其他人(de)权限,每一个用执行(x)-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答:chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答:chmod a+w,a+r 个人体会(你对本次实验有什么体会或看法)操作系统实验报告(三)文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令;2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题:1)vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2)在vi中退出时,保存并退出(de)操作步骤是Ese:wq3)用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令:cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4)请用至少两种不同(de)命令创建一个文本文件(),在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________;用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限(数字和字母)分别是多少__-rw- r- - r- - 6 4 4______________.6)若将该文件(de)访问权限修改为:所有者有读写权限;其他用户只读;同组用户可读写,请写出命令,并记录结果.7)查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8)在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息;file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题:1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结(本次实验(de)体会或小结)操作系统实验报告(四)作业调度算法模拟(验证性2学时)1、实验目(de):1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容:(1)作业调度算法(FCFS)编程模拟:编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1:FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}(2)作业调度算法(SJF)编程模拟:编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2:SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列:\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析:(对上述实验各题所使用(de)原始数据、调试数据与状态(包括出错)及最终结果进行记录并分析.)随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结:你对本次实验有什么体会或看法.。
操作系统lab2实验报告

操作系统lab2实验报告操作系统 Lab2 实验报告一、实验目的本次实验着重学习操作系统内存管理的相关概念和技术,包括页表的建立和管理,以及虚拟内存系统的实现和优化。
通过完成本实验,我们能够加深对操作系统内存管理机制的理解,并掌握相关的实现方法。
二、实验环境本次实验使用的实验环境为 Linux 操作系统(具体版本号)、GCC 编译器(具体版本号)以及所提供的模拟器。
三、实验内容本次实验主要包括以下几个任务:1. 理解虚拟内存和物理内存的概念,掌握页表的结构和管理方法。
2. 编写代码实现一个简单的页表建立和管理的模拟器,包括页表的初始化、地址映射和页表的更新。
3. 实现一个简单的虚拟内存系统,包括页的加载、替换等操作。
4. 对实现的虚拟内存系统进行性能优化,包括缓存算法的改进、预加载等策略的应用。
四、实验步骤及结果1. 理解虚拟内存和物理内存的概念在本次实验中,我们将使用虚拟内存系统来管理进程的地址空间。
虚拟内存是操作系统提供给进程的一种抽象概念,它为每个进程提供了一个独立的、连续的地址空间。
物理内存是实际存在的计算机内存,由物理地址组成。
2. 编写页表管理模拟器代码根据实验要求,我们需要编写代码模拟页表的建立和管理过程。
首先,我们需要实现页表的初始化函数,用于初始化页表的数据结构。
接着,我们需要实现地址映射函数,用于将虚拟地址映射到物理地址。
最后,我们需要实现页表的更新函数,用于更新页表中的相关信息。
3. 实现虚拟内存系统在本次实验中,我们需要实现一个简单的虚拟内存系统。
虚拟内存系统可以将虚拟地址映射到物理地址,并且可以实现页的加载和替换操作。
我们需要实现页面加载函数,用于将页面加载到内存中。
同时,我们还需要实现页面替换函数,当内存空间不足时,根据特定的算法选择待替换的页,并将其移出内存。
4. 性能优化为了提高虚拟内存系统的性能,我们可以采用一些优化策略。
例如,我们可以改进缓存算法,通过提前缓存一些可能会被访问的页面,减少缺页次数。
操作系统实验报告2doc

操作系统实验报告2篇一:操作系统实验二实验报告操作系统实验报告——实验二:线程和管道通信实验一、实验目的通过 Linux 系统中线程和管道通信机制的实验,加深对于线程控制和管道通信概念的理解,观察和体验并发进(线)程间的通信和协作的效果 ,练习利用无名管道进行进(线)程间通信的编程和调试技术。
二、实验说明1) 与线程创建、执行有关的系统调用说明线程是在共享内存中并发执行的多道执行路径,它们共享一个进程的资源,如进程程序段、文件描述符和信号等,但有各自的执行路径和堆栈。
线程的创建无需像进程那样重新申请系统资源,线程在上下文切换时也无需像进程那样更换内存映像。
多线程的并发执行即避免了多进程并发的上下文切换的开销又可以提高并发处理的效率。
pthread 库中最基本的调用。
1.pthread_create 系统调用语法:#includeInt pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *) Void *arg);pthread_create 函数创建一个新的线程。
pthread_create 在 thread 中保存新线程的标识符。
Attr 决定了线程应用那种线程属性。
使用默认可给定参数 NULL; (*start_routine) 是一个指向新线程中要执行的函数的指针 arg 是新线程函数携带的参数。
Pthread_create 执行成功会返回0并在 thread 中保存线程标识符。
执行失败则返回一个非0的出错代码2.pthread_exit 系统调用语法:#includevoid pthread_exit(void *retval);pthread_exit 函数使用函数pthread_cleanup_push 调用任何用于该线程的清除处理函数,然后中止当前进程的执行,返回 retval。
操作系统实验二报告

实验报告实验课程:操作系统实验项目:进程调度实验日期:系:计算机班级:姓名:学号:实验目的:进程调度时进程管理的主要内容之一,通过设计,编制,调试一个简单的进程调度模拟系统,对进程调度,进程运行状态变换及PV操作加深理解和掌握。
实验器材:实验室计算机一台实验内容:1.模拟批处理多道操作系统的进程调度;2.模拟实现同步机构避免并发进程执行时可能与时间相关的错误;实验题目:采用剥夺式优先算法,对三个进程进行模拟调度模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。
提示:(1)对三个进程进行模拟调度,对各进程的优先数静态设置,P1,P2,P3三个进程的优先数为1,2,3,并指定P1的优先数最高,P3的优先数最低,每个进程都处于执行态“e”,就绪态“r”,等待态“w”三种状态之一,并假定初始态为“r”。
(2)每一个进程用一个PCB表,PCB表的内容根据具体情况设置,该系统在运行过程中能显示或打印各进程和参数的变化情况,以便观察各进程的调度。
(3)在完成必要的初始化后,便进入进程调度程序,首先由P1进入执行,当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时,转进程调度。
(4)在进入临界区前后,调PV操作。
(5)如果被唤醒的进程优先数高于现有执行的进程,则剥夺现行进程的执行权。
(6)当三个进程都处于等待状态时,本模拟系统退出执行。
示例:1.数据结构:(1)进程控制块PCBstruct{int id;char status;int priority;int waiter1;}(2)信号量struct{int value;int waiter2;}sem[2](3)现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈,用来保护被中断时的断点地址等信息。
(4)全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
操作系统实验报告2

操作系统实验报告班级:XXXXXXXX 学号:XXXXXXXXX 姓名:XXXX一、实验题目:采用剥夺式优先算法,对三个进程进行模拟调度模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。
二、实验目的:通过设计,编制,调试一个简单的进程调度模拟系统,对进程调度,进程运行状态变换及PV操作加深理解和掌握。
三、实验内容:1.模拟批处理多道操作系统的进程调度;2.模拟实现同步机构避免并发进程执行时可能与时间相关的错误;四、实验过程:1.算法流程图:2.源代码:#include <stdafx.h>#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;char sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}return 0;}char input() /* 建立进程控制块函数*/{int i,num;//clrscr(); /*清屏*/printf("\n 请输入被调度的进程数目:");scanf("%d",&num);for(i=1;i<=num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}return 0;}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ {printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->super);printf("%d\t",pr->ntime);printf("%d\t",pr->rtime);return 0;}char check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}return 0;}char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->name);free(p);return 0;}char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}return 0;}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......"); ch=getchar();}printf("\n\n 进程已经完成.\n"); ch=getchar();}五、实验结果:1.设置进程数目:2.进程的调度运行:六、总结:该实验利用进程调度中的优先级算法调度进程,开始给每一个进程设定一个优先级数,对于优先级高的进程先调度,优先级低的进程后调度,在调度一个进程时,其他进程将处于就绪态,而正在被调度的进程应处于运行态。
操作系统实验报告通用(两篇)2024

操作系统实验报告通用引言:操作系统是计算机系统中的一个重要组成部分,它主要负责管理计算机硬件和软件资源,并为用户提供一个友好的界面。
操作系统实验是计算机科学与技术专业的一门重要实践课程,通过实际操作和实验验证,可以深入理解操作系统的工作原理和实现方法。
本文将以《操作系统实验报告通用》为题,从引言概述、正文内容、总结等方面详细阐述操作系统实验的一般结构和内容。
概述:操作系统实验是计算机科学与技术专业的一门实践课程,通过实际操作和实验验证来了解操作系统的工作原理和实现方法。
在操作系统实验中,学生将学习操作系统的基本概念、运行机制和实现技术,并通过实验验证来加深对操作系统的理解。
操作系统实验通常涉及到操作系统的各个模块,如进程管理、文件系统、内存管理等,并通过实际操作来了解操作系统的具体实现。
操作系统实验通常包括实验报告、实验代码以及实验总结等部分。
正文内容:1. 实验背景和目的1.1 实验背景在操作系统实验中,学生将学习操作系统的基本概念、运行机制和实现技术,通过实验来了解操作系统的具体实现和应用。
1.2 实验目的操作系统实验的主要目的是通过实际操作和实验验证来加深对操作系统的理解,并培养学生的动手能力和解决问题的能力。
2. 实验内容2.1 实验一:进程管理进程管理是操作系统中的核心模块之一,它负责管理和调度系统中的进程。
在这个实验中,学生需实现一个简单的进程管理器,并能够模拟多个进程的并发执行和互斥访问。
2.2 实验二:文件系统文件系统是操作系统中的另一个重要模块,它负责管理和组织计算机中的文件和目录。
在这个实验中,学生需实现一个简单的文件系统,并能够进行文件的创建、打开、读写和关闭操作。
2.3 实验三:内存管理内存管理是操作系统中的关键模块之一,它负责管理系统中的内存资源。
在这个实验中,学生需实现一个简单的内存管理器,并能够进行内存的分配和释放操作。
2.4 实验四:设备管理设备管理是操作系统中的另一个重要模块,它负责管理和调度计算机中的各种设备。
操作系统实验二实验报告

实验二处理机管理(4学时)实验目的正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏,在操作系统中调度的实质是一种资源分配,调度算法是指根据系统的资源分配策略规定的资源分配算法,对不同的系统和系统目标,应采用不的调度算法。
(或)在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个。
也就是说能运行的进程数远远大于处理机个数。
为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择一进程占用处理机。
通过本实验,加深对处理机调度的理解。
实验内容处理机管理是操作系统中非常重要的部分。
为深入理解进程管理部分的功能,设计几个调度算法,模拟实现处理机的调度。
编程模拟FCFS调度算法、SJ(P)F算法、高优先权调度算法、基于时间片轮转调度算法。
注:“基于时间片轮转调度算法模拟”为必作,其余选做。
实验准备及实验设备计算机,Tc2.0实验步骤正确理解各调度算法的基本思想;根据各调度算法定义PCB(模拟)的格式:FCFS算法和基于时间片轮转调度算法,可设PCB的格式为:高优先权调度算法可设PC为:在正确理解各调度算的基础上编写出相应的程序。
在所设计的调度程序中,针对不同算法应包含显示和打印语句,以便显示或打印程序运行的初值和运行结果:各PCB的初始状态,选中运行进程的名称、运行后各PCB状态以及每次调度时,就绪队列的进程排列顺序(针对不同算法有所不同)。
(源程序)实验结果(运行所编的模拟调度程序,所得结果略)FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。
SJ(P)F算法不利于长作业(进程),该算法未考虑作业的紧迫程序,因而不能保证紧迫性作业(进程)会被及时处理,并且由于作业(进程)的长短是用户所提供的估计执行时间而定的,致使该算法不一定能真正做到短作业优先调度。
高优先权(分动态和静态优先权)调度算法即照顾了短作业,又考虑了作业到达的紧迫性。
对于静态优先权法,系统开销小,但不够精确,可能出现优先权低的作业(进程)长期没有被调度的情况;对于动态优先权(高响应比优先)法,它既照顾了短作业,又考虑了作业的先后次序,不会使长作业长期得不到服务,但每要进行调度之前,都须做响应比的计算,会增加系统开销。
操作系统实验二(4)实验报告【模板范本】

exit(0);
}
}
}
六、程序运行时的初值和运行结果
七、实验体会
管道通过lockf(),而lockf(fd[1], 1, 0)实现进程间的互斥,用write()写入管道,用read()读取管道内容,通过延迟一段时间,sleep(),子进程完成写入任务,由于管道中的延迟问题,否则在未完成写任务时,父进程调用读任务,则出错。
而父进程则从管道中读出来自两个进程的信息,显示在屏幕上。
四、设计思路和流程图
五、源程序:
#include〈unistd。h>
#include〈signal。h〉
#include <stdio.h>
#include "stdlib。h”
int pid1,pid2;
main()
{
int fd[2];
char outpipe[100],inpipe[100];
pipe(fd);
while((pid1=fork())==-1);
if(pid1==0)
{
lockf(fd[1],1,0);
sprintf(outpipe,"child 1 process is sending message!”);
/*把串放入数组outpipe中*/
write(fd[1],outpipe,50); /*向管道写长为50字节的串*/
(4)了解Linux系统中进程通信的基本原理.
一、实验题目
编制一段程序,实现进程的管道通信.使用系统调用pipe()建立一条管道线。两个子进程p1和p2分别向通道个写一句话:
child1processis sending message!
最新操作系统实验报告实验二

最新操作系统实验报告实验二实验目的:1. 熟悉最新操作系统的架构和特性。
2. 掌握操作系统的基本操作和配置方法。
3. 分析操作系统的性能和稳定性。
实验环境:- 硬件环境:Intel Core i7处理器,16GB RAM,256GB SSD。
- 软件环境:最新操作系统版本X.Y.Z,图形界面和命令行界面。
实验步骤:1. 安装最新操作系统X.Y.Z,记录安装过程中的关键步骤和遇到的问题。
2. 配置系统环境,包括网络设置、显示设置、用户账户管理等。
3. 测试文件系统的性能,包括文件的创建、复制、删除和搜索操作。
4. 测试多任务处理能力,通过同时运行多个应用程序来观察系统响应时间和资源分配情况。
5. 检验系统的安全性,包括用户权限管理、防火墙设置和病毒防护功能。
6. 评估系统的稳定性,进行长时间运行测试,记录是否有崩溃或异常行为发生。
7. 对系统进行基准测试,使用专业工具如SPEC CPU测试套件来评估系统性能。
实验结果:1. 安装过程中,系统顺利识别硬件并完成驱动安装,未遇到兼容性问题。
2. 系统配置简便,图形用户界面直观易用,网络配置通过向导快速完成。
3. 文件系统测试显示,读写速度达到预期标准,搜索操作响应迅速。
4. 多任务处理测试中,系统在开启多个资源密集型应用时仍保持流畅,未出现明显延迟。
5. 安全性测试表明,用户权限分级明确,防火墙和病毒防护均能有效工作。
6. 稳定性测试中,系统连续运行72小时无故障,表现出良好的稳定性。
7. 基准测试结果显示,系统性能较前一版本有显著提升,特别是在多线程处理方面。
实验结论:最新操作系统X.Y.Z在本次实验中表现出了良好的性能和稳定性。
系统的用户界面友好,配置和管理方便。
文件系统和多任务处理能力均达到预期目标,安全性和稳定性也符合最新的操作系统标准。
推荐对性能和稳定性有较高要求的用户进行升级。
操作系统实验报告

计算机操作系统实验报告院系:班级:学号:姓名:实验二进程调度1.目的和要求通过这次实验,理解进程调度的过程,进一步掌握进程状态的转变、进程调度的策略,进一步体会多道程序并发执行的特点,并分析具体的调度算法的特点,掌握对系统性能的评价方法。
2.实验内容阅读教材《计算机操作系统》第二章和第三章,掌握进程管理及调度相关概念和原理。
编写程序模拟实现进程的轮转法调度过程,模拟程序只对PCB进行相应的调度模拟操作,不需要实际程序。
假设初始状态为:有n个进程处于就绪状态,有m个进程处于阻塞状态。
采用轮转法进程调度算法进行调度(调度过程中,假设处于执行状态的进程不会阻塞),且每过t个时间片系统释放资源,唤醒处于阻塞队列队首的进程。
程序要求如下:1)输出系统中进程的调度次序;2)计算CPU利用率。
3.实验环境Windows操作系统、VC++6.0 C语言4.设计思想每个进程有一个进程控制块( PCB—type)表示。
进程控制块可以包含如下信息:进程名(pid),需要运行时间(cpu—time),进程状态(state)等等。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是执行 2,就绪 1、阻塞0。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的运行时间减1,然后把它插入就绪队列尾部等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。
当就绪队列的进程全都完成以后将阻塞进程队首进程插入到就绪队列尾部以便下次进行调用,反复直到阻塞队列为空,进程全部执行完成则退出。
5.源程序#include <stdio.h>#include <stdlib.h>struct PCB_type{int pid ; //进程名int state ; //进程状态2--表示"执行"状态1--表示"就绪"状态0--表示"阻塞"状态int cpu_time ; //运行需要的CPU时间(需运行的时间片个数)};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队列队尾指针int static use_cpu,unuse_cpu;/*定义进程的数目*///读入假设的数据,设置系统初始状态void start_state(){int m,n,i;struct QueueNode *p;printf("输入就绪状态进程和阻塞状态进程个数n,m:");scanf("%d%d",&n,&m);printf("就绪进程状态\n");p=(struct QueueNode *)malloc(sizeof(struct QueueNode ));p->next=NULL;ready_head=ready_tail=p;for(i=0;i<n;i++){struct QueueNode *p;p=(struct QueueNode *)malloc(sizeof(struct QueueNode ));p->next=NULL;printf("Enter %d process pid:",i+1);scanf("%d",&p->PCB.pid);printf("Enter %d process cpu_time:",i+1);scanf("%d",&p->PCB.cpu_time);p->PCB.state=1;ready_tail->next=p;ready_tail=p;}p=ready_head->next;i=1;printf("\n");while(p){printf("第%d个进程:%d %d 和%d\n",i,p->PCB.pid,p->PCB.state,p->PCB.cpu_time);p=p->next;i++;}printf("阻塞进程状态");p=(struct QueueNode *)malloc(sizeof(struct QueueNode ));p->next=NULL;blocked_head=blocked_tail=p;for(i=0;i<m;i++){struct QueueNode *p;p=(struct QueueNode *)malloc(sizeof(struct QueueNode ));p->next=NULL;printf("Enter %d process pid:",i+1);scanf("%d",&p->PCB.pid);printf("Enter %d process cpu_time:",i+1);scanf("%d",&p->PCB.cpu_time);p->PCB.state=0;blocked_tail->next=p;blocked_tail=p;}p=blocked_head->next;i=1;printf("\n");while(p){Printf(“第%d个进程:%d %d和%d\n",i,p->PCB.pid,p->PCB.state,p->PCB.cpu_time);p=p->next;i++;}}//模拟调度void dispath(){struct QueueNode *p;int x=0,t;printf("输入时间片t:");scanf("%d",&t);use_cpu=0;unuse_cpu=0;while(ready_head!=ready_tail || blocked_head!=blocked_tail) {if (ready_head!=ready_tail){p=ready_head->next;ready_head->next=p->next;p->next=NULL;if(ready_head->next==NULL)ready_tail=ready_head;p->PCB.state =2;printf("进程%d\n",p->PCB.pid);p->PCB.cpu_time--;use_cpu++;if (p->PCB.cpu_time>0){p->PCB.state =1;ready_tail->next =p;ready_tail=p;}else{printf("进程%d已完成\n",p->PCB.pid);free(p);}}else{unuse_cpu++;}x++;if(blocked_head!=blocked_tail && x==t){p=blocked_head->next;blocked_head->next=p->next;if(blocked_head->next==NULL)blocked_tail=blocked_head;//p->next=NULL;ready_tail->next=p;ready_tail=p;p->next=NULL;x=0;}}printf("%d\n",unuse_cpu);printf("%d\n",use_cpu);}//计算CPU利用率void calculate(){double f;f=(double)use_cpu/use_cpu+unuse_cpu;printf("PCB的利用率为%lf",f);}void main(){start_state();dispath();calculate();}6.实例运行结果7.实验总结还好,操作系统的实验用C语言写,作为大学里学的第一门语言,C我还是学的不错的,虽然有很多的东西忘了,但是通过这次的实验,很多东西我都详细来了,尤其是链表的用法,只是中间有一些错误,不知道怎么搞了,还是自己学的不好,要不就不会有错误了,下次一定会注意的。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
计算机电子信息工程学院实验报告
成绩________
课程名称计算机操作系统指导教师杨秀华实验日期 2011年9月28、10月12 院(系)计算机学院专业班级09计算机科学技术实验地点 B-4009 学生姓名学号
实验项目名称实验二进程调度
计算机电子信息工程学院实验报告(附页)
程序参考代码:
参考代码:
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb
{ /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
void sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ { /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
void input() /* 建立进程控制块函数*/
{
int i,num;
printf("\n 请输入进程号?");
scanf("%d",&num);
for(i=0;i<num;i++)
{
printf("\n 进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort(); /* 调用sort函数*/
}
}
int space()
{
int l=0; PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
Void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ {
printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
Void check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
Void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
Void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='w';
sort(); /*调用sort函数*/
}
Void main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一键继续......");
ch=getchar();
}
printf("\n\n 进程已经完成.\n");
ch=getchar();
}。