东北大学操作系统试验5
东北大学linux实验报告
东北大学linux实验报告东北大学Linux实验报告引言：在当今信息技术高速发展的时代，计算机科学与技术已经成为了各个领域不可或缺的一部分。
作为计算机领域的重要组成部分，操作系统在实际应用中起着至关重要的作用。
Linux作为一种开源的操作系统，具有稳定性、安全性和灵活性等优势，因此在学术界和工业界均得到了广泛的应用和研究。
本文将对东北大学Linux实验进行总结和分析，以期对Linux操作系统有更深入的了解。
一、实验背景东北大学开设的Linux实验课程旨在帮助学生掌握Linux操作系统的基本原理和应用技巧。
通过实验，学生能够了解Linux的启动过程、文件系统管理、用户权限管理、网络配置等关键概念和操作。
实验采用了虚拟机技术，使得学生可以在实验室或家中的个人电脑上进行实验，提高了实验的灵活性和便捷性。
二、实验内容1. Linux的安装与启动在本实验中，我们首先需要在虚拟机中安装Linux操作系统。
通过选择适当的Linux发行版和版本，进行分区、格式化、安装等步骤，最终完成Linux的安装。
安装完成后，我们需要了解Linux的启动过程，包括BIOS、MBR、GRUB等关键环节。
2. 文件系统管理Linux操作系统以文件为中心，因此文件系统管理是Linux实验的重要内容之一。
通过实验，我们学会了使用命令行和图形界面两种方式来管理文件和目录，包括创建、删除、复制、移动、重命名等操作。
此外，还学习了文件权限和所有权的概念，掌握了chmod、chown等命令的使用方法。
3. 用户权限管理在Linux系统中，用户权限管理是非常重要的一部分。
通过实验，我们学会了创建用户、设置密码、分配权限等操作。
同时，还了解了Linux的用户组概念，学习了添加用户到用户组、设置用户组权限等操作。
4. 网络配置网络配置是Linux实验中的另一个重要内容。
通过实验，我们了解了网络接口的配置和管理，包括IP地址、子网掩码、网关等参数的设置。
操作系统实验报告1-5
shift
done
echo count is $count
2、自己设计编00以内基数的和：
三、实验总结
Shell在执行命令时，先进行变量替换，然后进行文件名替换，在给变量赋值是不进行文件名替换。要特别注意一些参数和字符串匹配的正确形式。在本试验中采用Vi编辑shell脚本，使我熟悉了基本程序命令的运用。操作系统课实验结束，但为了更深刻的理解操作系统的原理，在以后的学习过程中还应注重此方面知识的积累，并和老师及同学进行探讨。
操作系统实验报告
姓名：
学号：
实验1：Linux虚拟机的安装与配置
一、实验目的：
1、熟悉VM虚拟机软件的安装与使用
2、安装Linux虚拟机
3、进行Linux简单的配置
二、实验内容
1、安装VM虚拟机软件
2、安装Linux虚拟机
部署方案：8G空间为/主分区（根目录），2G空间为swap（交换分区）
/home用户home目录所在地
4、用gcc –c a.c编译程序，判断是否能够正常编译。若不能编译，检查系统的安装包是否包含gcc开头的软件包。
无法正常编译，因为检查系统的安装包是否包含gcc开头的软件包，安装gcc-后即可正常编译。
三、实验总结
加载光盘出问题了，花了较多时间，感觉很不好，又查阅了一些资料，在a.c编程时，语言环境不熟，但用Vi编程，基本的还能有以前学C语言时的感觉，这些操作都要自己多熟悉，软件可通过命令或直接安装。
实验3：Linux软件维护
一、实验目的：
1、熟悉Linux的软件安装方式
2、完成开发环境的配置
二、实验内容（程序见实验截图）
【免费下载】东北大学操作系统第三次实验报告
命中次数++
被访问次数最少的
进程退出
};
int page_no;
char flag;
struct one_frame M_Frame[frame_num];
int main()
{
int i,j,k,t,m,kk,r1,r2,p1,p2;
int temp1,temp2,temp3;
int diseffect1=0,diseffect2=0;
实验 5：页面置换算法
一、 题目：编程实现 FIFO 和 LRU 算法
二、 目的： 进一步理解父子进程之间的关系； 理解内存页面调度的机理； 掌握页面置换算法的实现方法； 通过实验比较不同调度算法的优劣； 培养综合运用所学知识的能力。 页面置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页面调度
int k1=0,k2=0,f1=0,f2=0;
float f;
int Access_series[total_instruction];
for(i=0; i<frame_num; i++) M_Frame[i].page_no=-1; printf("页面: ");
for(i=0; i<8; i++)
对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，系电，力根通保据过护生管高产线中工敷资艺设料高技试中术卷资，配料不置试仅技卷可术要以是求解指，决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资，配料而置试且时卷可，调保需控障要试各在验类最；管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下，安与要全过加，度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高；试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中，核资或对料者定试对值卷某，弯些审扁异核度常与固高校定中对盒资图位料纸置试，.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置，弯高尤曲中其半资要径料避标试免高卷错等调误，试高要方中求案资技，料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高，术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术，管以术来架及避等系免多统不项启必方动要式方高，案中为；资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资，管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装，工置合作调理并试利且技用进术管行，线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确：指灵在导活分。。线对对盒于于处调差，试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷，术调应问试采题技用，术金作是属为指隔调发板试电进人机行员一隔，变开需压处要器理在组；事在同前发一掌生线握内槽图部内 纸故，资障强料时电、，回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资，料料线试试缆卷卷敷试切设验除完报从毕告而，与采要相用进关高行技中检术资查资料和料试检，卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。
《操作系统》课程实验内容和实验要求
实验内容和实验要求实验1:安装Linux系统(4学时)目的:1.学会在操作系统安装之前,根据硬件配置情况,制订安装计划。
2.学会在安装多操作系统前,利用硬盘分区工具(如PQMagic)为Linux准备分区。
3.学会Linux操作系统的安装步骤和简单配置方法。
4.学会Linux系统的启动、关闭步骤,初步熟悉Linux系统的用户界面。
内容:1.安装并使用硬盘分区工具(如PQMagic),为Linux准备好分区。
2.安装Linux系统(如红旗Linux桌面版)。
3.配置Linux系统运行环境。
4.正确地启动、关闭系统。
5.对图形界面进行一般操作。
要求:1.制订安装计划。
2.如果在机器上已安装了Windows系统,而且没有给Linux预备硬盘分区,则安装硬盘分区工具(如PQMagic),运行它,为Linux划分出一块“未分配”分区。
3.在光驱中放入Linux系统安装盘,启动系统。
按照屏幕提示,选择/输入相关参数,启动安装过程。
4.安装成功后,退出系统,取出安装盘。
重新开机,登录Linux系统。
5.对Linux系统进行配置,如显示设备、打印机等。
6.利用鼠标对图形界面进行操作。
说明:1.本实验应在教师的授权和指导下进行,不可擅自操作,否则可能造成原有系统被破坏。
2.如条件不允许每个学生亲自安装,可采用分组进行安装或课堂演示安装的方式。
实验2:Linux 应用及shell编程(4学时)目的:1.掌握Linux一般命令格式和常用命令。
2.学会使用vi编辑器建立、编辑文本文件。
3.了解shell的作用和主要分类。
4.学会bash脚本的建立和执行方式。
5.理解bash的基本语法。
6.学会编写简单的shell脚本。
内容:1.正确地登录和退出系统。
2.熟悉使用date,cal等常用命令。
3.进入和退出vi。
利用文本插入方式建立一个文件。
4.学会用gcc编译器编译C程序。
5.建立shell脚本并执行它。
6.学会使用shell变量和位置参数、环境变量。
操作系统实验报告
命令名
功能
Ps
显示进程状态
Pstree
显示进程树（display a tree of processes）
Kill
给进程发信号
Killhall
按名给进程发信号(kill processes by name)
Skill,snice
报告进程状态（report process status）
(set and get scheduling algorithm/parameters)
sched_rr_get_interval
查看指定进程的SCHED_RR值(get the SCHED_RR interval for the named process)
f. Linux/UNIX进程管理类系统调用(4):与进程跟踪/进程运行时间有关的系统调用(2个)
设置静态优先级范围(get static priority range)
sched_setparam,sched_getparam
设置/查看调度参数
(set and get scheduling parameters)
sched_setscheduler,sched_getscheduler
设置/查看调度算法和参数
7,进程状态START。
8,队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：
1,进程在就绪队列中呆一个时间片，优先数加1。
<程序3>
#include<stdio．h>
main()
{
int p1，p2，i；
while((pl = fork ( ) ) ==-1);
操作系统实验全(五个)
操作系统试验指导—. 课程的性质、目的和任务操作系统在整个计算机系统软件中占有中心地位。
其作用是对计算机系统进行统一的调度和管理，提供各种强有力的系统服务，为用户创造既灵活又方便的使用环境。
本课程是计算机及应用专业的一门专业主干课和必修课。
通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。
二. 实验的意义和目的操作系统是计算机专业学生的一门重要的专业课程。
操作系统质量对整个计算机系统的性能和用户对计算机的使用有重大的影响。
一个优良的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。
培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。
通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。
使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。
三.实验运行环境及上机前的准备实验运行环境: C语言编程环境上机前的准备工作包括：●按实验指导书要求事先编好程序；●准备好需要输入的中间数据；●估计可能出现的问题；●预计可能得到的运行结果。
四. 实验内容及安排实验内容包括进程调度、银行家算法、页式地址重定位模拟，LRU算法模拟和先来先服务算法五个实验。
每个实验介绍了实习的目的要求、内容和方法。
实验一、进程调度试验[目的要求]用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．[准备知识]一、基本概念1、进程的概念；2、进程的状态和进程控制块；3、进程调度算法；二、进程调度1、进程的状态2、进程的结构——PCB进程都是由一系列操作(动作)所组成，通过这些操作来完成其任务。
东北大学操作系统实验报告
课程编号：B080000070《操作系统》实验报告姓名班级指导教师石凯实验名称《操作系统》实验开设学期2016-2017第二学期开设时间第11周——第18周报告日期2017年7月3日评定成绩评定人石凯评定日期2017年7月5日东北大学软件学院实验一进程的同步与互斥实验题目：通过学习和分析基础例子程序，使用windows进程和线程编程（也可以采用Java 或Unix/Linux的POSIX线程编程）实现一个简单的生产者/消费者问题的程序。
关键代码：import java.util.ArrayList;public class Produce {public Object object;public ArrayList<Integer> list;//用list存放生产之后的数据，最大容量为1public Produce(Object object,ArrayList<Integer> list ){this.object = object;this.list = list;}public void produce() {synchronized (object) {/*只有list为空时才会去进行生产操作*/try {while(!list.isEmpty()){System.out.println("生产者"+Thread.currentThread().getName()+" waiting");object.wait();}int value = 9999;list.add(value);System.out.println("生产者"+Thread.currentThread().getName()+" Runnable");object.notifyAll();//然后去唤醒因object调用wait方法处于阻塞状态的线程}catch (InterruptedException e) {e.printStackTrace();}}}}import java.util.ArrayList;public class Consumer {public Object object;public ArrayList<Integer> list;//用list存放生产之后的数据，最大容量为1public Consumer(Object object,ArrayList<Integer> list ){this.object = object;this.list = list;}public void consmer() {synchronized (object) {try {/*只有list不为空时才会去进行消费操作*/while(list.isEmpty()){System.out.println("消费者"+Thread.currentThread().getName()+" waiting");object.wait();}list.clear();System.out.println("消费者"+Thread.currentThread().getName()+" Runnable");object.notifyAll();//然后去唤醒因object调用wait方法处于阻塞状态的线程}catch (InterruptedException e) {e.printStackTrace();}}}}实验结果：思考题：（1）如何控制进程间的相互通信？答：主要有：管道，信号，共享内存，消息队列（2）什么是进程的同步？什么是进程的互斥？分别有哪些实现方式？答：进程互斥是进程之间的间接制约关系。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
东北大学操作系统实验之Linux及进程状态
操作系统实验报告一实验一进程状态转换及其PCB的变化一、实验目的：自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。
二、实验内容及要求：（1）、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。
（2）、独立编写、调试程序。
进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。
（3）、合理设计与进程PCB相对应的数据结构。
PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。
（4）、设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。
（5）、代码书写要规范，要适当地加入注释。
（6）、鼓励在实验中加入新的观点或想法，并加以实现。
（7）、认真进行预习，完成预习报告。
(8)、实验完成后，要认真总结，完成实验报告。
五状态模型：三、主要数据结构：struct Run_type //运行态进程{char name;int state;int needtime;int priority;};struct Ready_type //就绪态进程{char name;int needtime;int priority;};struct Blocked_type //阻塞态进程{char name;int needtime;int priority;};四、程序源代码：#include<stdio.h>#include<stdlib.h>#include<string.h>int i=0; int j=0;struct Run_type{char name;int state;int needtime;int priority;};struct Ready_type{char name;int needtime;int priority;};struct Blocked_type{char name;int needtime;int priority;};struct Run_type Cpu;struct Ready_type Ready[10];struct Blocked_type Blocked[10];void Creat(){ //创建一个新的进程int k=0;label1:printf(" input new process name(input a letter): \n");scanf("%s",&(Ready[i].name));getchar();for(k=0;k<i;k++)if(Ready[i].name==Ready[k].name||Ready[i].name==Ready[k].name+32||Ready[i].n ame==Ready[k].name-32){printf("the process is already exist!");goto label1;}printf("input needtime (input a int number):\n");label3:scanf("%d",&(Ready[i].needtime));getchar();if(Ready[i].needtime<1||Ready[i].needtime>100){printf("please input the true needtime(1--100)\n");goto label3;}printf(" input the priority(1--10): \n");label2:scanf("%d",&(Ready[i].priority));getchar();if(Ready[i].priority<1||Ready[i].priority>10){printf("please 1--10!\n");goto label2;}i++;}void Dispath() //P135{int t;char v;int k;int j;if(Cpu.state==0)if(Ready[i-1].needtime==0){printf("* there is no process ready!\n");exit(0);}else{for(k=0;k<i-1;k++)for(j=0;j<i-k-1;j++)if(Ready[j].priority>Ready[j+1].priority){t=Ready[j].priority;Ready[j].priority=Ready[j+1].priority;Ready[j+1].priority=t;t=Ready[j].needtime;Ready[j].needtime=Ready[j+1].needtime;Ready[j+1].needtime=t;v=Ready[j].name;Ready[j].name=Ready[j+1].name;Ready[j+1].name=v;}--i;=Ready[i].name;Cpu.needtime=Ready[i].needtime;Cpu.priority=Ready[i]. priority;Cpu.state=1;printf("*%5c is send to cpu! \n",);Cpu.needtime--;if(Cpu.needtime==0){printf("*%5c is finished \n",);Cpu.state=0;}}else{Ready[i].name=;Ready[i].needtime=Cpu.needtime;Ready[i].priority=Cpu.priority;for(k=0;k<i;k++)for(j=0;j<i-k;j++)if(Ready[j].priority>Ready[j+1].priority){t=Ready[j].priority;Ready[j].priority=Ready[j+1].priority;Ready[j+1].priority=t;t=Ready[j].needtime;Ready[j].needtime=Ready[j+1].needtime;Ready[j+1].needtime=t;v=Ready[j].name;Ready[j].name=Ready[j+1].name;Ready[j+1].name=v;}=Ready[i].name;Cpu.needtime=Ready[i].needtime;Cpu.priority=Ready[i]. priority;Cpu.state=1;printf("*%5c is send to cpu! \n",);Cpu.needtime--;if(Cpu.needtime==0){printf("*%5c is finished \n",);Cpu.state=0;}}}void Timeout(){if(Cpu.state==0){printf("* there is no process in cpu(please select Dispath!\n");exit(0);}else{Ready[i].name=;Ready[i].needtime=Cpu.needtime;Ready[i].priority=Cpu.priority;printf("%c is timeout \n",);=0;Cpu.needtime=0;Cpu.priority=0;Cpu.state=0;i++;}}void Eventwait(){if(Cpu.state!=0){Blocked[j].name=;Blocked[j].needtime=Cpu.needtime;Blocked[j].priority=Cpu.priority;printf("* %c is Blocked !\n",);j++;=Blocked[j].name;Cpu.needtime=Blocked[j].needtime;Cpu.priority=Blocked[j].priority;Cpu.state=0;}elseprintf("* There is no process in cpu!");}void Eventoccurs(char a){int k=0;int m=0;int n=0;int p=0;if(Blocked[0].needtime==0){printf("* there is no process blocked!\n");exit(0);}else{for(k;k<j;k++)if(Blocked[k].name==a){Ready[i].name=Blocked[k].name;Ready[i].needtime=Blocked[k].needtime;Ready[i].priority=Blocked[k].priority;p=1;m=j-k;for(n;n<m;n++){Blocked[k].name=Blocked[k+1].name;Blocked[k].needtime=Blocked[k+1].needtime;Blocked[k].priority=Blocked[k+1].priority;k++;}j--;i++;}if(p==1)printf("* %c is ready!\n",a);elseprintf("* %c is not found! \n",a);}}void main(){Cpu.state=0;int Cputime=0;int x=6;while(x!=0){printf("\n1:input new process 2:Dispath\n");printf("3:Timeout4:Eventwait\n");printf("5:Eventoccurs(select whose eventoccur ) 0:exit\n");label4:scanf("%d",&x);getchar();printf("\n==============================================================================\n");if(x==0||x==1||x==2||x==3||x==4||x==5){switch(x){case 1:Creat();break;case 2:Dispath();break;case 3:Timeout();break;case 4:Eventwait();break;case 5:char a;scanf("%c",&a);getchar(); Eventoccurs(a);break;default:printf("please select from 0 to 5\n");}printf("----------------------------- Cputime:%3d----------------------------------\n",Cputime);printf("| ProceNsname NeedTime Priority |\n");if(Cpu.state!=0)//显示Cpu中的程序{printf("| Cpu:%16c",);printf("%20d",Cpu.needtime);printf("%18d|\n",Cpu.priority);}elseprintf("| * Cpu is free |\n");int y=0;if(i==0)//显示Ready队列中的数据{printf("| *There is no process ready. |\n");}else{for(y;y<i;y++)//显示Ready中的程序{printf("| Ready%d:",y);printf("%15c",Ready[y].name);printf("%20d",Ready[y].needtime);printf("%18d|\n",Ready[y].priority);}}int z=0;if(j==0) //显示Blocked队列中的程序{printf("| *There is no process blocked. |\n");}else{for(z;z<j;z++){printf("| Blocked%d:",z);printf("%13c",Blocked[z].name);printf("%20d",Blocked[z].needtime);printf("%18d |\n",Blocked[z].priority);}}Cputime++;if(Cpu.state!=0)Cpu.needtime=Cpu.needtime-1;printf("-----------------------------------------------------------------------------\n");}else{printf("please input 0--5\n");goto label4;}}}五、运行结果：1.创建a，b两个进程2、调度进程（由于b优先级高，所以b先进入运行态）3、当b时间片到了，b变为就绪态4、再次调度（由于b优先级高，故还是b变成运行态）5、正在运行的b阻塞6、当b等待的事件发生，b重新进入就绪态六、程序使用说明：编译程序后若无错就执行程序，初始如下：其中：1表示创建新进程，随后输入进程名，所需时间，优先级 2表示系统调度进程，首先调度最高优先级3表示时间片已到，运行中的进程将编程就绪态4表示进程所需的事件尚未发生，进程将被阻塞5表示进程等待的事件已发生，进程从阻塞态变为就绪态 0退出程序10。
东北大学操作系统实验报告
= nam;
process.status = "r2";
re.push_back(process);
cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
cout << endl;
if(ru.empty())
{
cin >> act;
if(act == 2)
ruTOre();
else if(act == 3)
ruTObl();
else if(act == 4)
blTOre();
else if(act == 5)
neTOre();
else if(act == 6)
ruTOex();
else
cout << "Error in select."<<endl;
class Pro //process class
{
public:
char name;
string status;
};
vector<Pro> ru,re,bl; //ru->running,re->ready,bl->blocked
//function declaration
int helloUI();
基础内容:编写程序使其模拟两个进程，即生产者（producer）进程和消费者(Consumer)进程工作；生产者每次产生一个数据，送入缓冲区中；消费者每次从缓冲区中取走一个数据。每次写入和读出数据时，都将读和写指针加一。当指针到达缓冲区尾，重新将指针退回起点；
操作系统实验报告
write：用于写文件。
read：用于读文件。
rm：用于删除文件。
思考：
（1）如果引入磁盘索引结点，上述实现过程需要哪些修改？
（2）如果设计的是一个多用户文件系统，则又要进行哪些扩充？
3实验结果（给出编写的程序源代码和运行结果的截图并回答思考问题）
源代码：
实验心得：
基本上实现了DOS下简单文件系统的实现，通过学习基本掌握了文件系统的存储结构
（5）要求提供以下有关的操作：
format：对文件存储器进行格式化，即按照文件系统的结构对虚拟磁盘空间进行布局，并在其上创建根目录以及用于管理文件存储空间等的数据结构。
mkdir：用于创建子目录。
rmdir：用于删除子目录。
ls：用于显示目录。
cd：用于更改当前目录。
create：用于创建文件。
open：用于打开文件。
ID 0 1 2 3 4
PRIORITY 9 38 30 29 0
CPUTIME 0 0 0 0 0
ALLTIME 3 3 6 3 4
STARTBLOCK 2 -1 -1 -1 -1
BLOCKTIME 3 0 0 0 0
STATE ready ready ready ready ready
（5）为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：
（3）置换算法：请分别考虑OPT、FIFO和LRU算法。
（4）作业中指令的访问次序按下述原则生成：
•50%的指令是顺序执行的。
•25%的指令是均匀分布在前地址部分。
•25%的指令时均匀分布在后地址部分。
3实验结果（给出编写的程序源代码和运行结果的截图）
操作系统实验报告
操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理和关键机制，包括进程管理、内存管理、文件系统以及设备管理等方面。
同时，培养我们解决实际问题的能力，提高对操作系统相关知识的综合运用水平。
二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux（Ubuntu 2004 LTS），实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容及步骤（一）进程管理实验1、进程创建与终止在 Windows 系统中，使用 C+＋语言编写程序，通过调用系统 API函数创建新的进程，并观察进程的创建和终止过程。
在 Linux 系统中，使用 C 语言编写程序，通过 fork(）系统调用创建子进程，并通过 wait(）函数等待子进程的终止。
2、进程调度观察Windows 和Linux 系统中进程的调度策略，包括时间片轮转、优先级调度等。
通过编写程序模拟进程的执行，设置不同的优先级和执行时间，观察系统的调度效果。
（二）内存管理实验1、内存分配与释放在 Windows 系统中，使用 C+＋语言的 new 和 delete 操作符进行内存的动态分配和释放，并观察内存使用情况。
在 Linux 系统中，使用 C 语言的 malloc(）和 free(）函数进行内存的分配和释放，通过查看系统的内存使用信息来验证内存管理的效果。
2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制，包括页表、地址转换等。
通过编写程序访问虚拟内存地址，观察系统的处理方式和内存映射情况。
（三）文件系统实验1、文件操作在 Windows 和 Linux 系统中，使用编程语言对文件进行创建、读取、写入、删除等操作。
观察文件的属性、权限设置以及文件在磁盘上的存储方式。
2、目录操作实现对目录的创建、删除、遍历等操作。
研究目录结构和文件路径的表示方法。
东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图
int data = 0;//生产者生产的数据
int num = 0;//缓冲区元素个数
int np = 0;//正在等待的生产者
int nc = 0;//正在等待的消费者
int main()
{
print();
char c;
while(scanf("%c",&c)!='e')
buffer.push(ch);
buffer.pop();
}
printf("\n");
}
三、实验结果
实验三进程的管道通信
一、实验目的
加深对进程概念的理解，明确进程和程序的区别。
学习进程创建的过程，进一步认识进程并发执行的实质。
分析进程争用资源的现象，学习解决进程互斥的方法。
学习解决进程同步的方法。
掌握Linux系统中进程间通过管道通信的具体实现。
read(fd[0],father,17);
cout << father << endl;
}
}
}
return 0;
}
三、实验结果
实验四页面置换算法
一、实验目的
进一步加深理解父子进程之间的关系及其并发执行。
理解内存页面调度的机理。
掌握页面置换算法及其实现方法。
培养综合运用所学知识的能力。
二、实验内容
#include <iostream>
{
if(Acess_Series[i] == M_Frame[j])//命中
{
cout << "子程序2 命中： " ;
2019年东北大学编程实验报告-推荐word版 (7页)
本文部分内容来自网络整理，本司不为其真实性负责，如有异议或侵权请及时联系，本司将立即删除！== 本文为word格式，下载后可方便编辑和修改！ ==东北大学编程实验报告篇一：东北大学数据库实验报告 201X数据库实验报告班级：计算机1105班学号：201X3263姓名：张少杰时间：201X年6月19日实验(一): 熟练掌握SQL语言实验目的：熟悉上机环境，创建数据库，在数据库上建立关系模式，插入数据，进行相应的查询操作。
实验内容：具体包括如下三部分。
一、熟悉上机环境。
客户/服务器结构，数据库服务器在一台NT服务器上，同学们通过客户机(操作系统为Windows 201X)上安装的SQL Server客户端程序, 使用SQL Server数据库服务器。
具体包括：1. 了解SQL Server 环境。
鼠标点击开始，进入“Microsoft SQL Server?企业管理器”，点击SQL Server组下的数据库服务器（服务器名称为NEUC-201S(Windows NT)）, 可以看到服务器上的圆形标志变为绿色，说明客户端程序已与服务器连接成功。
点击服务器（NEUC-201S(Windows NT)）下的数据库，可以看到服务器上已建立的数据库，你可访问你有权访问的数据库，并进行相应的操作功能。
因为，数据库服务器上建有许多数据库, 每个数据库都有一些合法的用户。
2. 鼠标点击开始，进入“Microsoft SQL Server?查询分析器”，输入用户名和口令，进入SQL查询分析器。
如：你登录的客户机为27号，那么请以用户名user27，口令为user27登录，登录后缺省连到数据库user27上，user27/user27是数据库user27的创建者，因此用户user27/ user27具有在数据库user27上创建表等一切权力。
3. 在SQL查询分析器环境下，你就可进行SQL命令语句操作了。
二、在数据库useri上创建学生选课有关关系模式，并插入相应的数据，实现有关查询。
《操作系统》课程综合性的实验报告
《操作系统》课程综合性的实验报告一、实验目的本次《操作系统》课程的综合性实验旨在通过实际操作和实践，深入理解操作系统的基本原理、功能和运行机制。
具体目标包括熟悉操作系统的进程管理、内存管理、文件系统管理以及设备管理等核心模块，提高对操作系统的整体认知和应用能力。
二、实验环境本次实验在以下环境中进行：操作系统：Windows 10 专业版开发工具：Visual Studio 2019编程语言：C+＋三、实验内容及步骤（一）进程管理实验1、创建多个进程使用 C+＋中的多线程库，创建多个进程，并观察它们的并发执行情况。
通过设置不同的优先级和资源需求，研究进程调度算法对系统性能的影响。
2、进程同步与互斥实现生产者消费者问题，使用信号量、互斥锁等机制来保证进程之间的同步和互斥。
观察在不同并发情况下，数据的正确性和系统的稳定性。
（二）内存管理实验1、内存分配与回收模拟内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
通过随机生成内存请求，观察不同算法下内存的利用率和碎片情况。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小和页表结构，观察页面置换算法（如 FIFO、LRU 等）对内存访问性能的影响。
（三）文件系统管理实验1、文件操作创建、读取、写入和删除文件，了解文件系统的基本操作和数据结构。
2、文件目录管理实现文件目录的创建、遍历和搜索功能，研究目录结构对文件访问效率的影响。
（四）设备管理实验1、设备驱动程序模拟编写简单的设备驱动程序，模拟设备的输入输出操作，如键盘输入和屏幕输出。
2、设备分配与调度研究设备分配算法，如先来先服务和优先级算法，观察设备的使用情况和系统的响应时间。
四、实验结果与分析（一）进程管理实验结果分析1、在创建多个进程的实验中，发现高优先级进程能够更快地获得CPU 资源，系统响应时间更短。
但过度提高某些进程的优先级可能导致其他进程饥饿。
2、对于进程同步与互斥问题，正确使用信号量和互斥锁能够有效地保证数据的一致性和系统的稳定性。
东北大学操作系统实验一报告精编版
东北大学操作系统实验一报告文件编码（008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256）操作系统实验报告班级物联网1302班学号姓名实验一：熟悉Linux系统目的：①熟悉和掌握Linux系统基本命令，熟悉Linux编程环境，为以后的实验打下基础。
启动退出、ls（显示目录内容）、cp（文件或目录的复制）、mv（文件、目录更名或移动）、rm（删除文件或目录）、mkdir（创建目录）、rmdir （删除空目录）、cd（改变工作目录）…C语言编辑、编译内容及要求：熟练掌握Linux基本文件命令；掌握Linux编辑程序、对源代码进行编译、连接、运行及调试的过程；认真做好预习，书写预习报告；实验完成后要认真总结、完成实验报告login：用户登录系统使用login命令可以允许用户登录系统。
如果没有指定参数，登录时提示输入用户名。
如果该用户不是root，且如果/etc/nologin文件存在，这个文件的内容被显示到屏幕上，登录被终止。
命令语法：Login [选项][用户名]exit：退出系统使用exit命令可以退出shell命令语法：exit[选项]ls:列出目录和文件信息使用ls命令，对于目录而言将列出其中的所有的子目录与文件信息，对于文件而言将输出命令语法：ls[选项][目录|文件]ls命令部分选项含义cp：复制文件和目录使用cp命令可以复制文件vhe目录到其他目录中。
如果同时指定两个以上的文件或目录，且最后的目的地是一个已经存在的目录，则它会把前面指定的所有的文件或目录复制到该目录中。
若同时指定多个文件或目录，而最后的目的地并非一个已存在的目录，则会出现错误信息。
命令语法：cp [选项][源文件|目录][目标文件|目录]cp命令部分选项含义Mv:可以用来移动文件或者将文件改名,是Linux系统下常用的命令，经常用来备份文件或者目录。
命令格式:mv[选项]源文件或目录目标文件或目录.mv命令部分选项含义rm:该命令的功能为删除一个目录中的一个或多个文件或目录，它也可以将某个目录及其下的所有文件及子目录均删除。
东北大学操作系统实验报告4-2017
东北⼤学操作系统实验报告4-2017实验四进程的管道通信⼀、实验⽬的1、加深对进程概念的理解，明确进程和程序的区别。
2、学习进程创建的过程，进⼀步认识进程并发执⾏的实质。
3、分析进程争⽤资源的现象，学习解决进程互斥的⽅法。
4、学习解决进程同步的⽅法。
5、掌握Linux系统中进程间通过管道通信的具体实现⼆、实验内容使⽤系统调⽤pipe()建⽴⼀条管道，系统调⽤fork()分别创建两个⼦进程，它们分别向管道写⼀句话，如：Child process1 is sending a message!Child process2 is sending a message!⽗进程分别从管道读出来⾃两个⼦进程的信息，显⽰在屏幕上注：实际要求最好创建两个以上⼦进程，但不需要太多三、实验要求1、这是⼀个设计型实验，要求⾃⾏、独⽴编制程序。
2、两个⼦进程要并发执⾏。
3、实现管道的互斥使⽤。
当⼀个⼦进程正在对管道进⾏写操作时，另⼀个欲写⼊管道的⼦进程必须等待。
使⽤系统调⽤lockf(fd[1],1,0)实现对管道的加锁操作，⽤lockf(fd[1],0,0)解除对管道的锁定。
4、实现⽗⼦进程的同步，当⽗进程试图从⼀空管道中读取数据时，便进⼊等待状态，直到⼦进程将数据写⼊管道返回后，才将其唤醒。
四、程序流程图⽗进程⼦进程五、程序代码及注释#include#include//写管程⽤到的那些函数⽤到的头⽂件#include#include//wait⽤到这个int main(){int fd[2];pipe(fd); //⽗进程创建管道char outpipe[50],inpipe[50]; //存放字符串int pid1,pid2,pid3; //存放返回值while((pid1 = fork()) == -1); //创建不成功就跳不出来了if(pid1 == 0) //⼦进程1{sleep(1); //sleep函数可以决定⼦进程的顺序，等的时间长的话进⼊就晚，输出也就晚lockf(fd[1], 1, 0); //对管道写⼊端⼝加锁sprintf(outpipe,"\n child process 1 is sending message !\n");write(fd[1], outpipe, 50); //把字符串内容写⼊管道写⼊⼝lockf(fd[1], 0, 0); //对管道写⼊⼝解锁exit(0);}else//⽗进程{while((pid2 = fork()) == -1);if(pid2 == 0) //⼦进程2{sleep(2);lockf(fd[1], 1, 0);sprintf(outpipe,"\n child process 2 is sending message !\n");write(fd[1], outpipe, 50);lockf(fd[1], 0, 0);exit(0);}else//⽗进程{while((pid3 = fork()) == -1);if(pid3 == 0) //⼦进程3{sleep(3);lockf(fd[1], 1, 0);sprintf(outpipe,"\n child process 3 is sending message !\n");write(fd[1], outpipe, 50);lockf(fd[1], 0, 0);exit(0);}else//⽗进程{wait(0); //阻塞，等待⼦进程read(fd[0], inpipe, 50); //从管道读出⼝读出信息放到数组printf("%s\n",inpipe);wait(0);read(fd[0], inpipe, 50);printf("%s\n",inpipe);wait(0);read(fd[0], inpipe, 50);printf("%s\n",inpipe); //三个⼦进程，要输出三次exit(0);}}}}六、运⾏结果及说明因为加了锁，不会出现⼦进程同时往管道⾥写的情况，所以，⼦进程互斥地往管道⾥写，⽗进程从管道⾥读并输出，就显⽰成了如上图模样注：⼀个之前不明⽩的流程由fork创建的新进程被称为⼦进程（child process）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验五：页面置换算法
1. 实验内容
程序涉及一个父进程和两个子进程。父进程 使用rand()函数随机产生若干随机数，经过处 理后，存于一数组Acess_Series[]中，作为 内存页面访问的序列。两个子进程根据这个 访问序列，分别采用FIFO和LRU两种不同的 页面置换算法对内存页面进行调度。
实验五：页面置换算法
实验五：页面置换算法
5. 主要数据结构 (仅供参考）
存放页面访问序列的数组 (Acess_Series[total_instruction]) 。 用一个结构数组M_Frame[]记录为进程分配的内存页 面的使用情况。在M_Frame[]中还可记载各页面进入 内存或被访问的先后顺序（如可使M_Frame[0]总是 最先进入或最久未被访问的页面）。 struct one_frame { int page_no; char flag; }; struct one_frame M_Frame[frame_num]; /这里 frame_num是给一个进程分配的最大的内存页面数
3. 实验要求
这是一个综合性实验，要求在掌握父子进程并发执行 机制和内存页面置换算法的基础上，能综合运用这两 方面的知识，自行、独立编制程序。 每个子进程应能反映出页面置换的过程，并统计页面 置换算法的命中或缺页情况。 设缺页的次数为diseffect。总的页面访问次数为 total_instruction。则： 缺页率 = disaffect/total_instruction 命中率 = 1- disaffect/total_instruction 将为进程分配的内存页面数mframe作为程序的参数， 通过多次运行程序，说明FIFO算法存在的Belady现象。
实验五：页面置换算法
7. 预习报告内容要求 实验的题目、目的、内容、要求 初步的程序流程图 初步的程序源代码、注释及必要的文字 说明 预期的程序内容要求 实验的题目、目的、内容、要求 程序流程图
程序源代码、注释及文字说明。
运行结果及其说明
实验五：页面置换算法
实验五：页面置换算法
6. 程序流程 (仅供参考）
父进程：
随机产生内存访问页面序列，存于数组 Acess_Series[total_instruction]中 数据结构M_Frame的初始化 分别创建两个子进程。 等待子进程执行结束，退出。
实验五：页面置换算法
6. 程序流程 (仅供参考）
子进程：
①读序列Acess_Series[]，若序列中已无下一个 元素，转5）；否则，取出页面序列中的下一个 元素作为下次要访问的页面； ②如果待访问的页面在内存中（即在M_Frame[] 中找到），则不发生缺页，命中率加1，转① ，注意LRU算法中要调整该页在数组中的位置 ；
8. 实验报告内容要求
回答以下问题： ①父进程、子进程之间的并发执行过程。 ② 通过完成实验，根据你的体会，阐述虚拟 存储器的原理。 ③写出FIFO算法中出现Belady现象的内存 页面访问序列。
实验五：页面置换算法
4. 相关的系统调用
exit() 是进程结束时最常调用的。 格式：void exit( int status); 其中，status为 进程结束状态。 sleep() 调用进程睡眠若干时间，之后唤醒。 格式：sleep(int t); 其中t为睡眠时间。 rand() 返回一个随机整数。 需要包含文件<stdlib.h>
实验五：页面置换算法
4. 相关的系统调用
fork() 用于创一个子进程。 格式：int fork(); 返回值：在子进程中返回0；在父进程中返回所创建 的 子进程的ID值；当返回-1时，创建失败。 wait() 常用来控制父进程与子进程的同步。 在父进程中调用wait()，则父进程被阻塞，进入等待 队列，等待子进程结束。当子进程结束时，父进程从 wait()返回继续执行原来的程序。 返回值：大于0时，为子进程的ID值；等于-1时，调
操作系统实验（五)
页面置换算法
实验五：页面置换算法
1. 实验目的
进一步加深理解父子进程 之间的关系及其并发执行。
理解内存页面调度的机理。 掌握页面置换算法及其实 现方法。 培养综合运用所学知识的
能力。
实验五：页面置换算法
1. 实验目的 页面置换算法是虚拟存储管理 实现的关键，通过本次试验理解 内存页面调度的机制，在模拟实 现FIFO、LRU等经典页面置换算 法的基础上，理解虚拟存储实现 的过程。 将不同的置换算法放在不同的 子进程中加以模拟，培养综合运 用所学知识的能力。
实验五：页面置换算法
6. 程序流程 (仅供参考） 子进程：
③否则就要将这页调入内存，通过修改相应的数据 结构M_Frame[]反映出来。首先看M_Frame[]中 有无空闲页面，如果有，将待访问页面的页号以及 被占用的信息写入数组中适当位置，并统计缺页情 况，缺页次数diseffect加1，返回① ； ④如果M_Frame[]中的所有页面均被占满，则淘汰 M_Frame[0]，装入待访问页，重新调整各页面 在数组中的位置。并统计缺页情况，缺页次数 diseffect加1，返回① ； ⑤所有页面均已访问完成，统计命中率或缺页率；