操作系统实验实验3
操作系统实验,实验3, 进程管理 (1)
在图形界面上利用终端通过命令“su - ”切换到超级用户,编辑文件 “job”; 按组合键[Ctrl+Alt+F2]切换到第二个虚拟终端(超级用户); 输入命令“at –f job now+1 minute”,设置1分钟后执行at调度内容; 稍等后观察at调度的执行效果,再切换到第一个虚拟终端观察at调度 的执行效果;
切换到第一个虚拟终端观察at调度的执行效果(5分钟后系统将执行重 启调度任务)。
[操作要求2] 设置一个调度,要求1分钟后执行文件job中的作业。 文件job的内容为: find /home/jkx/ -name “*.c” > /home/jkx/fdresult wall user jkx, all code files have been searched out! Please check out. [操作步骤]
续表
守 护 进 程 innd Usenet新闻服务器 功 能 说 明
linuxconf
lpd named netfs network
允许使用本地WEB服务器作为用户接口来配置机器
打印服务器 DNS服务器 安装NFS、Samba和NetWare网络文件系统 激活已配置网络接口的脚本程序
nfsd
portmap postgresql routed sendmail
事件(例如xinetd和lpd)
启动守护进程有如下几种方法
在引导系统时启动 人工手动从shell提示符启动
系统启动script的执行期间 被启动(/etc/rc.d) 任何具有相应执行 权限的用户
使用crond守护进程启动
执行at命令启动
守护进程一般由系统在开机时通过脚本或root
操作系统实验3-进程控制
WORD wMajorReq=(WORD)(dwVerReq>16);
WORD wMinorReq=(WORD)(dwVerReq&0xffff);
::cout<<"Process ID:"<<dwIdThis<<",requires OS:"<<wMajorReq<<wMinorReq<<::endl;
{
//改变优先级
::SetPriorityClass(
::GetCurrentProcess(), //利用这一进程
HIGH_PRIORITY_CLASS); //改变为high
//报告给用户
::cout<<"Task Manager should indicate this "
"process is high priority."<<::endl;
//设置版本信息的数据结构,以便保存操作系统的版本信息
OSVERSIONINFOEX osvix;
::ZeroMemory(&osvix,sizeof(osvix));
osvix.dwOSVersionInfoSize=sizeof(osvix);
//提取版本信息和报告
::GetVersionEx(reinterpret_cast<LPOSVERSIONINFO>(&osvix));
Parent();
}
return 0;
}
分析:程序4-3.cpp说明了一个进程从“生”到“死”的整个一生,第一次执行时,它创建一个子进程,其行为如同“父亲”。在创建子进程之前,先创建一个互斥的内核对象,其行为对于子进程来说,如同一个“自杀弹”。当创建子进程时,就打开了互斥体并在其他线程中进行别的处理工作,同时等待着父进程使用ReleaseMutex()API发出“死亡”信号。然后用Sleep()API调用来模拟父进程处理其他工作,等完成时,指令子进程终止。
操作系统实验三 时间片轮转法完成进程调度
实验三:时间片轮转法完成进程调度一、实验目的:(1)加深对进程的理解(2)理解进程控制块的结构(3)理解进程运行的并发性(4)掌握时间片轮转法进程调度算法实验内容:(1)建立进程控制块(2)设计三个链队列,分别表示运行队列、就绪队列和完成队列(3)用户输入进程标识符以及进程所需的时间,申请空间存放进程PCB信息。
(4)每一个时间片结束输出各进程的进程号,CPU时间(即已经占用的CPU时间),所需时间(即还需要的CPU时间),以及状态(即用W表示等待,R表示运行,F表示完成)实验程序:#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10];/*进程标识符*/int prio;/*进程优先数*/int round;/*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count;/*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; //队列指针int N,t; //进程数,时间片的大小void firstin(){run=ready;//就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态ready=ready->next; //就绪队列头指针后移到下一进程}void prt1(char a)//输出标题函数{if(toupper(a)=='P')//优先级法printf("进程名占用CPU时间到完成还要的时间轮转时间片状态\n");} void prt2(char a,PCB *q)//进程PCB输出{if(toupper(a)=='P')//优先级法的输出printf("%4s %8d %12d %14d %8c\n",q->name,q->cputime,q->needtime,q->roun d,q->state);}void prt(char algo)//输出函数二、三、{PCB *p;prt1(algo);//输出标题if(run!=NULL)//如果运行指针不空prt2(algo,run);//输出当前正在运行的PCBp=ready;//输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish;//输出完成队列的PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}void insert(PCB *q)//时间片轮转的插入算法{PCB *p1,*s,*r;s=q;//待插入的PCB指针p1=ready;//就绪队列头指针r=p1;//*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round){r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;//否则插入在就绪队列的头ready=s;}}void create(char alg)//时间片轮转法创建链表进程PCB{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("输入进程名及其需要运行的时间(中间以空格隔开):\n"); for(i=1;i<=N;i++){p=new PCB;scanf("%s %d",&na,&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';//进程的状态p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}printf("*************时间片轮转法进程调度过程*************\n"); prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg)//时间片轮转法{while(run!=NULL){run->cputime=run->cputime+t;//处理时间加trun->needtime=run->needtime-t;//完成需要时间减trun->round=run->round+t;//运行完将其变为完成态,插入完成队列if(run->needtime<=0)//当进程完成时{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)//就绪队列不空,将第一个进程投入进行firstin();}else{run->state='W';//将进程插入到就绪队列中等待轮转insert(run);//将就绪队列的第一个进程投入运行firstin();}prt(alg);}}void main()//主函数{char algo='P';//算法标记printf("输入进程的个数:");scanf("%d",&N);//输入进程数printf("定义时间片大小:");scanf("%d",&t);//输入时间片大小create(algo);//创建进程timeslicecycle(algo);//时间片轮转法调度}//main()四、实验结果:五、实验小结:时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。
操作系统实验3进程同步报告
实验三进程同步一、实验目的:1.了解进程和线程的同步方法,学会运用进程和线程同步方法来解决实际问题;2.了解windows系统下Win32 API或Pthread信号量机制的使用方法;二、实验预备内容:1.对书上所说基于信号量的有限缓冲的生产者-消费者问题;2.对于信号量的概念有大概的了解,知道如何用信号量的wiat()和signal()函数如何取消应用程序进入临界区的忙等;三、实验环境说明:此实验在Win7(32位) CodeBlocks环境下实现,采用WinAPI的信号量机制。
四、实验内容:设计一个程序解决有限缓冲问题,其中的生产者与消费者进程如下图所示。
在Bounded-Buffer Problem(6.6.1节)中使用了三个信号量:empty (记录有多少空位)、full(记录有多少满位)以及mutex(二进制信号量或互斥信号量,以保护对缓冲区插入与删除的操作)。
对于本项目,empty和full将采用标准计数信号量,而mutex将采用二进制信号量。
生产者与消费者作为独立线程,在empty、full、mutex的同步前提下,对缓冲区进行插入与删除。
本项目可采用Pthread或Win32 API。
(本实验采用Win32 API)五、程序设计说明:1.全局变量:定义缓冲区数组及其环形队列表达方式,定义mutex、empty、full 三个信号量。
empty记录缓冲区有多少个空位;full记录缓冲区有多少个满位;mutex作为互斥信号量,保护对缓冲区插入或删除的操作。
具体定义如下:定义生产者、消费者线程结构和包含的信息:(由于题目中没有要求,因此只定义了编号一个变量)2.缓冲区:缓冲区是一个元数据类型为buffer_item(可通过typedef定义)的固定大小的数组,按环形队列处理。
buffer_item的定义及缓冲区大小可保存在头文件中:A.insert_item():先判断缓冲区是否已满,不满则向缓冲区中插入元素;B.remove_item()先判断缓冲区是否为空,不空则从缓冲区中删除元素;3.生产者线程:生产者线程交替执行如下两个阶段:睡眠一段随机事件,向缓冲中插入一个随机数。
操作系统教学实践(3篇)
第1篇一、引言操作系统是计算机科学与技术领域的重要基础课程,它涉及计算机系统的资源管理、进程管理、存储管理、文件系统等多个方面。
为了提高学生对操作系统的理解和掌握程度,本文将从教学实践的角度,探讨如何进行操作系统教学。
二、教学目标1. 使学生掌握操作系统的基本概念、原理和关键技术;2. 培养学生分析和解决实际问题的能力;3. 增强学生的团队协作和创新能力;4. 提高学生的编程能力和动手能力。
三、教学内容1. 操作系统概述:介绍操作系统的定义、发展历程、分类和特点;2. 进程管理:讲解进程的概念、进程状态、进程调度算法和进程同步与互斥;3. 存储管理:分析内存分配策略、页面置换算法和虚拟内存技术;4. 文件系统:探讨文件系统的概念、目录结构、文件操作和存储设备管理;5. 设备管理:介绍设备的分类、驱动程序、I/O控制方式和中断处理;6. 网络操作系统:讲解网络操作系统的基本概念、网络协议、网络设备管理和网络安全。
四、教学实践1. 案例教学:通过实际案例,引导学生分析操作系统的原理和应用。
例如,以Linux系统为例,讲解进程调度、内存管理和文件系统等知识点。
2. 实验教学:设计实验项目,让学生动手实践操作系统的相关知识。
实验项目包括:(1)进程调度实验:让学生编写进程调度算法,实现进程的创建、调度和同步。
(2)内存管理实验:让学生实现内存分配、页面置换和虚拟内存等技术。
(3)文件系统实验:让学生实现文件系统的目录结构、文件操作和存储设备管理。
(4)设备管理实验:让学生编写设备驱动程序,实现设备的控制和管理。
3. 项目教学:以实际项目为背景,让学生分组完成项目开发。
项目可以包括:(1)操作系统模拟器:让学生模拟操作系统的运行过程,加深对操作系统原理的理解。
(2)嵌入式操作系统开发:让学生了解嵌入式操作系统的特点,掌握嵌入式开发技能。
(3)分布式操作系统开发:让学生了解分布式系统的原理,掌握分布式操作系统的开发方法。
实验三 Linux操作系统安全实验 (一)
实验三Linux操作系统安全一、实验目的及要求(一)实验目的通过实验熟悉Linux环境下的用户管理、进程管理以及文件管理的相关操作命令。
掌握linux操作系统中相关的系统安全配置方法,建立linux操作系统的基本安全框架。
(二)实验要求根据实验中介绍的Linux操作系统的各项安全性实验要求,详细观察记录设置前后系统的变化,给出分析报告。
使用RPM对系统的软件进行管理,验证系统内软件的完整性,并分析结果。
试比较Linux下网了服务安全设置与Windows下安全设置异同。
二、实验环境安装Red hat9.0操作系统的计算机一台三、实验内容1、账户和口令安全2、文件系统管理安全3、查看和更改PAM模块设置4、RPM软件管理5、系统安全配置四、实验步骤任务一账户和口令安全1、查看和添加账户(1)在X_Windows窗口中单击鼠标右键,选择“信件中断”,输入下面的命令行:[root@localhost root]#useradd mylist利用useradd命令新建名为mylist的新账户。
(2)输入命令行:[root@localhost root]#cat/etc/shadow利用cat查看系统中的账户列表。
用su命令切换到新建的账户,重复步骤(2),检查shadow文件的权限设置是否安全。
设置安全时,普通用户mylist应该没有查看该系统文件的权限。
在终端中出现如下的提示:Cat:/etc/shadow:权限不够2、添加和更改密码(1)在终端输入[root@localhost root]#passwd mylist为新建账户添加密码。
注意:系统管理员无需输入原来密码即可以利用passwd命令添加或改变任意用户的密码,但普通用户只能改变自己的密码。
(2)输入后依次出现如下提示:Changjing passwd for user mylist.New passwd:Retype new passwd:Passwd:all authentication tokens updated susscessfully.输入密码,Linux系统不会将输入显示出来。
《操作系统》实验报告三 页式虚拟存储管理中地址转换和缺页中断
实验项
目
名称
页式虚拟存储管理中地址转换和缺页中断
实验目的及要求1、深入了解页式存储管理如何实现地址转换。
2、进一步认识页式虚拟存储管理中如何处理缺页中断。
实验内容
编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。
假定内存64KB,每个内存块1024字节;作业最大支持到64KB,系统中每个作业分得内存块4块。
实验步骤
注:可根据实际情况加页。
实验3 操作系统的程序口
实验3 操作系统的程序口一、实验目的操作系统管理着计算机系统的所有软件资源和硬件资源。
为了让终端用户方便地使用计算机,一般操作系统都提供了人机界面,让计算机前的人能通过命令接口和图形接口来获取操作系统提供的服务。
另外,为了方便用户通过程序来使用计算机资源、获取操作系统提供的各种服务,操作系统还往往给用户提供了另外一个接口——程序接口,也叫系统调用。
系统调用可以看作是用户程序在程序一级请求操作系统为之服务的一种手段。
在操作系统的管理下,运行中的用户程序通过“程序口”或“系统调用”,使得当前处理机的状态发生改变(从用户态“自陷(陷入)”转变为系统态),从而执行操作系统提供的服务。
一旦系统调用完毕,处理机的状态就又会从系统态返回到用户态。
Linux操作系统的程序口就是它所说的“系统调用”,Windows操作系统则提供了一些API(Application Programming Interface)函数,用户通过这些函数,来引发操作系统的系统调用。
Visual Basic 6.0、Visual C++ 6.0是微软开发的两个十分流行的开发工具,本次实验将在这两个环境下进行。
通过该实验,意在让学生了解操作系统留给用户的程序接口,并在开发环境中体会一下程序口的使用方法。
二、实验内容和要求1.Windows API包括哪些方面的内容?Windows API 就是windows应用程序接口,是针对microsoft windows操作系统家族的系统编程接口,这样的系统包括Windows 7,Windows Vista、Windows XP、Windows Server 2003、Windows 2000、Windows 95、Windows 98、Windows Me(Millennium Editon)和Windows CE等几乎所有版本。
Windows API包括几千个可调用的函数,它们大致可以分为:基本服务、组件服务、用户界面服务、图形多媒体服务、消息和协作、网络、Web服务2.什么是动态链接库?动态链接库英文为DLL,是Dynamic Link Library 的缩写形式,DLL是一个包含可由多个程序同时使用的代码和数据的库,DLL不是可执行文件。
计算机基础实验报告3
模块1——《Windows XP操作系统》实验报告3实验3:WindowsXP基本管理【实验目的】1 理解个性化工作环境的含义。
2掌握 Windows XP基本管理的意义。
3掌握写字板和剪贴板的基本操作方法。
4 掌握Windows XP汉字输入的基本操作方法。
【实验要求】1 掌握定制个性化工作环境的基本方法。
2掌握 Windows XP基本管理的操作方法。
3掌握写字板的启动、关闭和文本编辑的操作方法。
4 掌握汉字输入的基本操作方法。
【实验内容和步骤】1 .定制个性化工作环境(1)右击桌面无图标处,在弹出的快捷菜单中选择“属性”项,会弹出什么窗口?在弹出的窗口中单击“桌面”选项卡,预览区显示了什么?描述出现的内容。
选择“属性”会弹出选择桌面带屏护的外观设置,显示电脑屏幕的图案。
可弹出对话框选择自制的“菜单”。
(2)在“背景”列表框中随意单击几个图标名,预览区有什么变化?描述出现的内容;看见单击后的图案在显示框中显示出来。
(3)选定任意一个图标后,在窗口右侧的“位置”下拉选择框中分别选择不同的选项,预览区会有什么变化?描述出现的内容;显示居中、拉伸、平铺状态。
(4)单击“确定”按钮,产生什么结果?描述出现的内容;是选定或修改后的程序选项,屏幕保护程序运行。
(5)再次打开“显示属性”窗口,单击“屏幕保护程序”选项卡,在“屏幕保护程序”下拉选择框中选定“三维飞行物”,再单击“预览”按钮,屏幕显示什么?描述出现的内容;全屏显示“三维飞行物”的屏幕保护图。
(6)单击任务栏的无图标处,在弹出的快捷菜单中选择“属性”项,会弹出什么窗口?弹出“任务栏和[开始]菜单属性”窗口。
(7)在弹出的窗口中选中“自动隐藏任务栏”选择框,再单击“确定”按钮。
使鼠标指针在屏幕底边移动,会有什么结果?描述出现的内容;鼠标指针移动到屏幕底边,才显示任务栏,离开屏幕底边,自动隐藏任务栏。
〔8)单击任务栏的无图标处,在弹出的快捷菜单中使鼠标指针指向“工具栏”项并在打开的子菜单中选择“快速启动”项,任务栏有何变化?再次选择“快速启动”项,任务栏又有何变化?描述出现的内容;在任务栏上显示“快速启动”图标,再次选择“快速启动”项,任务栏上就不显示“快速启动”图标。
电脑实践课实验报告(3篇)
第1篇实验名称:计算机基本操作与常用软件应用实验日期:2023年3月15日实验地点:计算机实验室实验目的:1. 掌握计算机的基本操作,包括开关机、文件管理、系统设置等。
2. 熟悉常用软件的使用,如文字处理软件、电子表格软件、演示文稿软件等。
3. 提高计算机应用能力,为后续课程学习打下基础。
实验内容:一、计算机基本操作1. 开关机操作(1)打开计算机,等待系统启动完成。
(2)使用鼠标点击屏幕左下角的“开始”按钮,选择“关机”选项。
(3)系统提示是否保存更改,根据实际情况选择保存或取消保存。
(4)点击“确定”按钮,等待计算机完全关闭。
2. 文件管理(1)打开文件资源管理器,了解文件结构。
(2)创建文件夹:点击“文件”菜单,选择“新建”->“文件夹”,输入文件夹名称,按“确定”按钮。
(3)重命名文件或文件夹:选中文件或文件夹,右击鼠标,选择“重命名”,输入新名称,按“Enter”键。
(4)删除文件或文件夹:选中文件或文件夹,右击鼠标,选择“删除”,在弹出的对话框中选择“是”。
3. 系统设置(1)打开“控制面板”,了解系统设置。
(2)调整屏幕分辨率:在“控制面板”中找到“显示”选项,调整分辨率。
(3)设置网络连接:在“控制面板”中找到“网络和共享中心”,设置网络连接。
二、常用软件应用1. 文字处理软件(Microsoft Word)(1)创建新文档:点击“开始”按钮,选择“所有程序”->“MicrosoftOffice”->“Microsoft Word”,打开Word软件。
(2)输入文字:在文档中输入文字,可以使用“格式”工具栏进行文字格式设置。
(3)保存文档:点击“文件”菜单,选择“保存”或“另存为”,设置保存路径和文件名,点击“保存”按钮。
2. 电子表格软件(Microsoft Excel)(1)创建新工作簿:点击“开始”按钮,选择“所有程序”->“Microsoft Office”->“Microsoft Excel”,打开Excel软件。
四川大学操作系统课程设计第三次实验报告生产者和消费者
实验报告(学生打印后提交)实验名称: 生产者和消费者问题实验时间: 2023年 5 月 5日●实验人员:●实验目的:掌握基本的同步互斥算法, 理解生产者和消费者模型。
●了解Windows 2023/XP中多线程的并发执行机制, 线程间的同步和互斥。
●学习使用Windows 2023/XP中基本的同步对象, 掌握相应的API●实验环境: WindowsXP + VC++6.0●运用Windows SDK提供的系统接口(API, 应用程序接口)完毕程序的功能。
API是操作系统提供的用来进行应用程序设计的系统功能接口。
使用API, 需要包含对API函数进行说明的SDK头文献, 最常见的就是windows.h实验环节:1.读懂源程序.2.编辑修改源程.......................................实验陈述:1.基础知识:本实验用到几个API函数:CreateThread CreateMutex, WaitForSingleObject, ReleaseMutexCreateSemaphore, WaitForSingleObject, ReleaseSemaphore, ReleaseMutex, nitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection。
这些函数的作用:CreateThread, 功能:创建一个线程, 该线程在调用进程的地址空间中执行。
CreateMutex,功能:产生一个命名的或者匿名的互斥量对象。
WaitForSingleObject(相应p操作)锁上互斥锁, ReleaseMutex(相应v操作)打开互斥锁.。
CreateSemaphore, 创建一个命名的或者匿名的信号量对象。
信号量可以看作是在互斥量上的一个扩展。
WaitForSingleObject, 功能:使程序处在等待状态, 直到信号量(或互斥量)hHandle出现或者超过规定的等待最长时间, 信号量出现指信号量大于或等于1, 互斥量出现指打开互斥锁。
操作系统实验报告三
操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能,通过实际操作和观察,增强对操作系统原理的理解和掌握,提高解决实际问题的能力。
二、实验环境本次实验在 Windows 10 操作系统环境下进行,使用了 Visual Studio 2019 作为编程工具,并借助了相关的操作系统模拟软件和调试工具。
三、实验内容与步骤(一)进程管理实验1、创建多个进程使用 C++语言编写程序,通过调用系统函数创建多个进程。
观察每个进程的运行状态和资源占用情况。
2、进程同步与互斥设计一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。
分析在不同并发情况下程序的执行结果,理解进程同步的重要性。
(二)内存管理实验1、内存分配与回收实现一个简单的内存分配算法,如首次适应算法、最佳适应算法或最坏适应算法。
模拟内存的分配和回收过程,观察内存的使用情况和碎片产生的情况。
2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制,通过查看系统性能监视器观察虚拟内存的使用情况。
编写程序来模拟虚拟内存的页面置换算法,如先进先出(FIFO)算法、最近最少使用(LRU)算法等。
(三)文件系统实验1、文件操作使用 C++语言对文件进行创建、读写、删除等操作。
观察文件在磁盘上的存储方式和文件目录的结构。
2、文件系统性能测试对不同大小和类型的文件进行读写操作,测量文件系统的读写性能。
分析影响文件系统性能的因素,如磁盘碎片、缓存机制等。
四、实验结果与分析(一)进程管理实验结果1、创建多个进程在创建多个进程的实验中,通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。
多个进程可以并发执行,提高了系统的资源利用率。
2、进程同步与互斥在生产者消费者问题的实验中,当使用正确的信号量机制时,生产者和消费者能够协调工作,不会出现数据不一致或死锁的情况。
操作系统实验
操作系统实验报告(一)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以后,缺页数目又再次减少了四、总结:你对本次实验有什么体会或看法.。
操作系统实验3--请求分页式存储管理
请求分页式存储管理一、问题描述设计一个请求页式存储管理方案,为简单起见。
页面淘汰算法采用FIFO页面淘汰算法,并且在淘汰一页时,只将该页在页表中修改状态位。
而不再判断它是否被改写过,也不将它写回到辅存。
二、基本要求页面尺寸1K,输入进程大小(例如5300bytes),对页表进行初始化页表结构如下:系统为进程分配:任意输入一个需要访问的指令地址流(例如:3635、3642、1140、0087、1700、5200、4355,输入负数结束),打印页表情况。
每访问一个地址时,首先要计算该地址所在的页的页号,然后查页表,判断该页是否在主存——如果该页已在主存,则打印页表情况;如果该页不在主存且页框未满(查空闲块表,找到空闲块),则调入该页并修改页表,打印页表情况;如果该页不在主存且页框已满,则按FIFO页面淘汰算法淘汰一页后调入所需的页,修改页表,打印页表情况。
存储管理算法的流程图见下页。
三、实验要求完成实验内容并写出实验报告,报告应具有以下内容:1、实验目的。
2、实验内容。
3、程序及运行情况。
4、实验过程中出现的问题及解决方法。
#include<stdio.h>#include<stdlib.h>int PUB[20][3];int ABC[3][2]={{0,1},{1,1},{2,1}};//物理块int key=0;void output(int size){//打印int i,j;printf("页号\t\t物理块号\t\t状态位\n\n");for(i=0;i<size;i++){printf(" %d\t\t%d\t\t\t%d\n\n",PUB[i][0],PUB[i][1],PUB[i][2]);}printf("物理块号\t\t是否空闲\n\n");for(i=0;i<3;i++){printf(" %d\t\t\t%d\n\n",ABC[i][0],ABC[i][1]);}}void main(){int size;int i,j;int address=0;int select=0;printf("请输入进程大小\n");scanf("%d",&size);if(size<=0 || size>20000){printf("进程大小超出范围\n");exit(0);}size%1000==0 ? size=size/1000 : size=size/1000+1;for(i=0;i<size;i++){PUB[i][0]=i; //页号PUB[i][1]=0; //物理块号PUB[i][2]=0; //状态位}output(size);while(1){printf("输入指令地址\n");scanf("%d",&address);if(address<0 || address>20000){printf("地址超出范围\n");exit(0);}address%1000==0 ? address=address/1000 : address=address/1000;if(PUB[address][2]==0) //不在主存{if(ABC[2][1]==0) //满了{printf("满了\n");if(select!=address) key++;for(i=0;i<size;i++){if(PUB[i][1]==key){PUB[i][1]=0;PUB[i][2]=0;}}PUB[address][1]=key;PUB[address][2]=1;key++;if(key>3) key=1;}if(ABC[2][1]==1) //没满{printf("没满\n");for(i=0;i<3;i++){if(ABC[i][1]==1){ABC[i][1]=0;PUB[address][1]=i+1;PUB[address][2]=1;break;}}}output(size);}else{printf("该页已在内存\n");output(size);}select=address;}}。
大学计算机实验3-实验报告
大学计算机实验3-实验报告大学计算机实验 3 实验报告一、实验目的本次实验旨在通过实际操作,加深对计算机相关知识的理解和掌握,提高我们的计算机应用能力和问题解决能力。
具体目标包括:1、熟悉特定计算机软件或工具的使用方法和功能。
2、培养我们的实践操作能力,能够独立完成相关任务。
3、增强对计算机系统和程序运行原理的认识。
二、实验环境本次实验在学校的计算机实验室进行,实验室配备了高性能的计算机设备,安装了所需的操作系统和软件工具,具体如下:1、操作系统:Windows 10 专业版。
2、应用软件:具体软件名称 1、具体软件名称 2等。
三、实验内容及步骤(一)实验任务一:任务一的具体描述1、启动相关软件,熟悉其操作界面和基本功能。
2、按照给定的要求,进行数据的输入和处理。
首先,打开具体文件或项目,在相应的位置输入数据。
然后,运用软件提供的功能对数据进行整理和分析。
3、观察数据处理的结果,检查是否符合预期。
(二)实验任务二:任务二的具体描述1、切换到另一个软件工具,了解其特点和使用规则。
2、依据给定的案例,进行模拟操作。
设定相关参数,如列举参数名称和取值。
运行程序,观察输出结果。
(三)实验任务三:任务三的具体描述1、综合运用之前所学的知识和技能,解决一个较为复杂的实际问题。
2、制定解决方案,明确操作流程。
3、逐步实施解决方案,在过程中不断调整和优化。
四、实验中遇到的问题及解决方法在实验过程中,遇到了一些问题,通过以下方法得以解决:1、问题一:在进行具体操作时,出现了错误描述的错误提示。
解决方法:查阅相关的帮助文档和在线资料,发现是由于原因分析导致的。
通过具体的解决步骤,成功解决了该问题。
2、问题二:对于某个概念或功能理解不够清晰,导致操作失误。
解决方法:向老师和同学请教,经过他们的耐心讲解和示范,加深了对该内容的理解,从而能够正确完成操作。
五、实验结果与分析(一)实验任务一的结果经过数据处理,得到了具体的结果描述。
操作系统安全实验3实验报告
操作系统安全实验3实验报告实验三:操作系统安全实验报告一、实验目的1.了解操作系统的安全机制;2.学习使用常见的安全技术和工具。
二、实验环境1. 操作系统:Windows 10;2. 编程语言:Python。
三、实验内容本次实验分为两个实验项目,分别是文件加密和进程权限控制。
1.文件加密文件加密是一种常见的安全技术,通过对目标文件进行加密,可以保护文件的内容不被未授权的用户访问。
本次实验要求编写一个文件加密程序,实现以下功能:(1)接受用户输入的文件路径和密钥;(2)对目标文件使用密钥进行加密,生成加密文件;(3)对加密文件使用相同的密钥进行解密,还原为原始文件。
2.进程权限控制进程权限控制是操作系统的一个重要安全机制,通过限制进程的权限,可以防止恶意程序对系统进行破坏。
本次实验要求编写一个进程权限控制程序,实现以下功能:(1)列出当前系统中所有的进程,并显示其ID和权限;(2)接受用户输入的进程ID和新的权限;(3)修改目标进程的权限为用户指定的权限。
四、实验步骤及结果1.文件加密(1)根据实验要求,编写一个文件加密程序,使用Python语言实现,并命名为encrypt.py。
(2)运行encrypt.py,输入要加密的文件路径和密钥。
(3)程序将对目标文件进行加密,并生成加密文件。
(4)运行encrypt.py,输入要解密的文件路径和密钥。
(5)程序将对加密文件进行解密,并还原为原始文件。
2.进程权限控制(1)根据实验要求,编写一个进程权限控制程序,使用Python语言实现,并命名为process_control.py。
(2)运行process_control.py,程序将列出当前系统中所有的进程,并显示其ID和权限。
(3)输入要修改权限的进程ID和新的权限。
(4)程序将修改目标进程的权限为用户指定的权限。
五、实验总结通过本次实验,我深入了解了操作系统的安全机制,并学习了使用常见的安全技术和工具。
操作系统实验报告实验3_1
操作系统实验报告实验3_1一、实验目的本次实验的主要目的是深入理解操作系统中进程管理的相关概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制,提高对操作系统内核工作原理的认知和实践能力。
二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行,使用了Visual Studio 2019 作为开发工具,编程语言为 C++。
三、实验内容与步骤(一)进程创建1、编写一个简单的 C++程序,使用系统调用创建一个新的进程。
2、在父进程和子进程中分别输出不同的信息,以区分它们的执行逻辑。
```cppinclude <iostream>include <windowsh>int main(){DWORD pid;HANDLE hProcess = CreateProcess(NULL, "childexe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pid);if (hProcess!= NULL) {std::cout <<"Parent process: Created child process with PID "<< pid << std::endl;WaitForSingleObject(hProcess, INFINITE);CloseHandle(hProcess);} else {std::cerr <<"Failed to create child process" << std::endl;return 1;}return 0;}```(二)进程调度1、设计一个多进程并发执行的程序,通过设置不同的优先级,观察操作系统对进程的调度情况。
2、记录每个进程的执行时间和等待时间,分析调度算法的效果。
```cppinclude <iostream>include <windowsh>DWORD WINAPI ProcessFunction(LPVOID lpParam) {int priority =(int)lpParam;DWORD start = GetTickCount();std::cout <<"Process with priority "<< priority <<"started" << std::endl;for (int i = 0; i < 100000000; i++){//执行一些计算操作}DWORD end = GetTickCount();DWORD executionTime = end start;std::cout <<"Process with priority "<< priority <<" ended Execution time: "<< executionTime <<" ms" << std::endl;return 0;}int main(){HANDLE hThread1, hThread2;int priority1 = 1, priority2 = 2;hThread1 = CreateThread(NULL, 0, ProcessFunction, &priority1, 0, NULL);hThread2 = CreateThread(NULL, 0, ProcessFunction, &priority2, 0, NULL);if (hThread1!= NULL && hThread2!= NULL) {SetThreadPriority(hThread1, THREAD_PRIORITY_LOWEST);SetThreadPriority(hThread2, THREAD_PRIORITY_NORMAL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);CloseHandle(hThread1);CloseHandle(hThread2);} else {std::cerr <<"Failed to create threads" << std::endl;return 1;}return 0;}```(三)进程同步与互斥1、实现一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。
北理操作系统实验三
操作系统课程设计实验报告实验名称:生产者消费者问题姓名/学号:一.实验目的1.学习掌握操作系统中进程之间的通信2.理解掌握使用信号量机制来多进程互斥访问共享内存区的控制3.学习进程的创建及控制,共享内存区的创建和删除,信号量的创建使用删除二.实验内容•一个大小为3的缓冲区,初始为空,每个缓冲区能存放一个长度若为10个字符的字符串。
•2个生产者–随机等待一段时间,往缓冲区添加数据,–若缓冲区已满,等待消费者取走数据后再添加–重复6次•3个消费者–随机等待一段时间,从缓冲区读取数据–若缓冲区为空,等待生产者添加数据后再读取–重复4次说明:•显示每次添加和读取数据的时间及缓冲区的状态•生产者和消费者用进程模拟,缓冲区用共享内存来实现三.实验环境VMware Fushion8:Windows和ubuntu14.10四.程序设计与实现1、Windows下:A:主要函数说明1.PROCESS_INFORMATION StartClone(int nCloneID)功能:创建一个克隆的进程并赋于其ID值,并返回进程和线程信息2.CreateProcess:创建进程3.CreateSemaphore():创建信号量4.CreateFileMapping():在当前运行的进程中创建文件映射对象,模拟共享内存区5.MapViewOfFile():在此文件映射基础上创建视图映射到当前应用程序的地址空间B:程序流程图(下图)C:实验结果:2、Linux下:A:主要函数说明1.void(p):申请缓冲区2.void(v):释放缓冲区3.shmget():用来获得共享内存区域的ID,如果不存在这个内存区,就创建这个共享内存区。
4.semget():返回信号量集的Id,如果不存在就创建这个信号量集B:程序流程图C:实验结果五. 实验收获与体会1、进一步熟悉了Windows 、Linux 中进程的创建与管理2、掌握了WINDOWS 和Linux 下进程之间的通信:Windows 主要在于句柄的获取并用于API 函数的调用,并利用文件映射创建共享缓冲区;Linux 主要使用信号量机制和相关API的调用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
大学学生实验报告一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
二、实验容实验1:设计一个虚拟存储区和存工作区,并使用下述算法计算访问命中率。
1、最佳淘汰算法(OPT)2、先进先出的算法(FIFO)3、最近最久未使用算法(LRU)4、最不经常使用算法(LFU)5、最近未使用算法(NUR)命中率=1-页面失效次数/页地址流长度实验2:在Linux环境下利用下列系统调用malloc(), free()编写一段程序实现存分配与回收的管理。
要求:1、返回已分配给变量的存地址;2、返回释放后的存地址;3、释放已分配的存空间后,返回释放存后未使用存的大小。
三、实验原理UNIX中,为了提高存利用率,提供了外存进程对换机制;存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入存。
这种页面调入方式叫请求调页。
为实现请求调页,核心配置了四种数据结构:页表、页框号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时存未满,能容纳新页,则启动磁盘I/O将所缺之页调入存,然后修改页表。
如果存已满,则须按某种置换算法从存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问存数据。
整个页面的调入过程对用户是透明的。
四、实验设备安装了Linux系统的电脑五、实验程序实验1:#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define INVALID -1//#define NULL 0#define total_instruction 320#define total_vp 32#define clear_period 50typedef struct{int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp];struct pfc_struct{int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail; int diseffect, a[total_instruction];int page[total_instruction], offset[total_instruction];int initialize(int);int FIFO(int);int LRU(int);int LFU(int);int NUR(int);int OPT(int);int main( ){int s,i,j;srand(10*getpid());s=(float)319*rand( )/32767/32767/2+1;for(i=0;i<total_instruction;i+=4){if(s<0||s>319){printf("When i==%d,Error,s==%d\n",i,s);exit(0);}a[i]=s;a[i+1]=a[i]+1;a[i+2]=(float)a[i]*rand( )/32767/32767/2;a[i+3]=a[i+2]+1;s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;if((a[i+2]>318)||(s>319))printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s); }for (i=0;i<total_instruction;i++){page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++){printf("---%2d page frames---\n",i);FIFO(i);LRU(i);LFU(i);NUR(i);OPT(i);}return 0;}int initialize(total_pf)int total_pf;{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID;pl[i].counter=0;pl[i].time=-1;}for(i=0;i<total_pf-1;i++){pfc[i].next=&pfc[i+1];pfc[i].pfn=i;}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0];return 0;}int FIFO(total_pf)int total_pf;{int i,j;pfc_type *p;initialize(total_pf);busypf_head=busypf_tail=NULL;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID){diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=INVALID;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:%6.4f\n",1-(float)diseffect/320); return 0;}int LRU (total_pf)int total_pf;{int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID){diseffect++;if(freepf_head==NULL){min=32767;for(j=0;j<total_vp;j++)if(min>pl[j].time&&pl[j].pfn!=INVALID){min=pl[j].time;minj=j;}freepf_head=&pfc[pl[minj].pfn];pl[minj].pfn=INVALID;pl[minj].time=-1;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn;pl[page[i]].time=present_time;freepf_head=freepf_head->next;}elsepl[page[i]].time=present_time;present_time++;}printf("LRU:%6.4f\n",1-(float)diseffect/320); return 0;}int NUR(total_pf)int total_pf;{int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID){diseffect++;if(freepf_head==NULL){cont_flag=TRUE;old_dp=dp;while(cont_flag)if(pl[dp].counter==0&&pl[dp].pfn!=INVALID) cont_flag=FALSE;else{dp++;if(dp==total_vp)dp=0;if(dp==old_dp)for(j=0;j<total_vp;j++)pl[j].counter=0;}freepf_head=&pfc[pl[dp].pfn];pl[dp].pfn=INVALID;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}elsepl[page[i]].counter=1;if(i%clear_period==0)for(j=0;j<total_vp;j++)pl[j].counter=0;}printf("NUR:%6.4f\n",1-(float)diseffect/320); return 0;}int OPT(total_pf)int total_pf;{int i,j, max,maxpage,d,dist[total_vp];pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID){diseffect++;if(freepf_head==NULL){for(j=0;j<total_vp;j++)if(pl[j].pfn!=INVALID) dist[j]=32767;else dist[j]=0;d=1;for(j=i+1;j<total_instruction;j++){if(pl[page[j]].pfn!=INVALID)dist[page[j]]=d;d++;}max=-1;for(j=0;j<total_vp;j++)if(max<dist[j]){max=dist[j];maxpage=j;}freepf_head=&pfc[pl[maxpage].pfn];freepf_head->next=NULL;pl[maxpage].pfn=INVALID;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}}printf("OPT:%6.4f\n",1-(float)diseffect/320); return 0;}int LFU(total_pf)int total_pf;{int i,j,min,minpage;pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID){diseffect++;if(freepf_head==NULL){min=32767;for(j=0;j<total_vp;j++){if(min>pl[j].counter&&pl[j].pfn!=INVALID) {min=pl[j].counter;minpage=j;}pl[j].counter=0;}freepf_head=&pfc[pl[minpage].pfn];pl[minpage].pfn=INVALID;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn;pl[page[i]].counter++;freepf_head=freepf_head->next;}elsepl[page[i]].counter++;}printf("LFU:%6.4f\n",1-(float)diseffect/320); return 0;}实验2#include<iostream>using namespace std;#include<stdlib.h>#include<stdio.h>#include<malloc.h>//#include<iostream>int main(){int *string;string=(int*) malloc(10);if(string==NULL)printf("Insufficient memory available\n");else{printf("Memory space allocated for path name\n"); cout<<"string="<<string<<endl;free(string);printf("Memory freed\n");}int *stringy;stringy=(int*)malloc(12);if(stringy==NULL)printf("Insufficient memory available\n");else{printf("Memory space allocated for path name\n");cout<<"stringy="<<stringy<<endl;free(stringy);printf("Memory freed\n");}}六、实验结果试验1:从几种算法的命中率看,OPT最高,其次为NUR相对较高,而FIFO与LRU相差无几,最低的是LFU。