山东大学 计算机 2011_操作系统实验报告_最终版

合集下载

《操作系统》实验报告

《操作系统》实验报告

《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一,本次实验的主要目的是深入理解操作系统的基本原理和功能,通过实际操作和观察,熟悉操作系统的核心概念,包括进程管理、内存管理、文件系统和设备管理等,提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在以下环境中进行:操作系统:Windows 10开发工具:Visual Studio 2019编程语言:C++三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。

在这个实验中,我们使用C++编写程序来创建和管理进程。

通过观察进程的创建、执行和结束过程,理解进程的状态转换和资源分配。

首先,我们编写了一个简单的程序,创建了多个子进程,并通过进程标识符(PID)来跟踪它们的运行状态。

然后,使用等待函数来等待子进程的结束,并获取其返回值。

在实验过程中,我们发现进程的创建和销毁需要消耗一定的系统资源,而且进程之间的同步和通信需要谨慎处理,以避免出现死锁和竞争条件等问题。

2、内存管理实验内存管理是操作系统的核心功能之一,它直接影响系统的性能和稳定性。

在这个实验中,我们研究了动态内存分配和释放的机制。

使用 C++中的 new 和 delete 操作符来分配和释放内存。

通过观察内存使用情况和内存泄漏检测工具,了解了内存分配的效率和可能出现的内存泄漏问题。

同时,我们还探讨了内存分页和分段的概念,以及虚拟内存的工作原理。

通过模拟内存访问过程,理解了页表的作用和地址转换的过程。

3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。

在这个实验中,我们对文件的创建、读写和删除进行了操作。

使用 C++的文件流操作来实现对文件的读写。

通过创建不同类型的文件(文本文件和二进制文件),并对其进行读写操作,熟悉了文件的打开模式和读写方式。

此外,还研究了文件的权限设置和目录的管理,了解了如何保护文件的安全性和组织文件的结构。

4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。

计算机操作系统实验报告

计算机操作系统实验报告

计算机操作系统实验报告一、实验目的本次计算机操作系统实验的主要目的是深入了解操作系统的工作原理和功能,通过实际操作和观察,增强对操作系统概念的理解,提高解决实际问题的能力。

二、实验环境1、操作系统:Windows 10 专业版2、开发工具:Visual Studio 20193、编程语言:C++三、实验内容1、进程管理实验创建多个进程,并观察它们的执行顺序和资源占用情况。

使用进程控制块(PCB)来跟踪进程的状态变化,如就绪、运行、阻塞等。

2、内存管理实验模拟内存分配和回收算法,如首次适应算法、最佳适应算法和最坏适应算法。

观察不同算法在内存利用率和分配效率方面的表现。

3、文件系统实验创建、读取、写入和删除文件,了解文件的操作流程。

研究文件的存储结构和目录管理方式。

4、线程同步与互斥实验使用互斥锁和信号量来实现线程之间的同步和互斥操作。

观察在多线程环境下资源竞争和同步的效果。

四、实验步骤1、进程管理实验步骤编写 C++程序,使用系统调用创建多个进程。

在每个进程中输出进程的标识符和当前执行时间。

通过观察控制台输出,分析进程的执行顺序和资源占用情况。

2、内存管理实验步骤实现不同的内存分配算法,并在程序中模拟内存请求和释放的过程。

记录每次内存分配和回收的结果,计算内存利用率和分配时间。

3、文件系统实验步骤使用文件操作函数创建文件,并写入一些数据。

读取文件中的数据,并将其输出到控制台。

删除文件,观察文件系统的变化。

4、线程同步与互斥实验步骤创建多个线程,共享一些公共资源。

在访问公共资源的代码段前使用互斥锁或信号量进行同步控制。

观察线程的执行结果,确保资源的正确访问和修改。

五、实验结果与分析1、进程管理实验结果与分析实验结果显示,进程的执行顺序是不确定的,取决于操作系统的调度策略和进程的优先级。

资源占用情况也因进程的不同而有所差异,一些进程可能占用较多的 CPU 时间和内存,而另一些则相对较少。

2、内存管理实验结果与分析首次适应算法在分配速度上较快,但容易产生内存碎片。

山东大学操作系统实验四实验报告

山东大学操作系统实验四实验报告

软件学院实验报告4实验题目:Nachos File System 学号: 201100300038日期:2013-10-30 班级: 11级3班姓名:陶旭涛Email:1595242630@实验目的:熟悉nachos系统的文件操作命令以及用法,了解怎样生成 Nachos 文件系统,知道怎样测试 Nachos 文件系统的基本功能,怎样检查 Nachos 文件系统中模拟硬盘中的内容。

硬件环境:Ubuntu12.04软件环境:Nachos,Mips,GDB实验步骤:按照操作命令按步执行:nachos [ d f] –f这个命令用于在任何其它文件系统命令使用之前格式化一个模拟的叫DISK 的硬盘: nachos [d f] –cp Unix 文件名 Nachos 文件名从 Unix 系统中拷贝一个文件到 Nachos 系统中:nachos [d f] –p 文件名显示 Nachos 系统中一个文件的内容(类似 Unix 系统中的 cat 命令):nachos [d f] –d 文件名删除 Nachos 系统中一个文件(类似 Unix 系统中的 rm 命令):nachos [d f] –l 列出 Nachos 系统中所有的文件名(类似 Unix 系统中的 ls 命令)结果如下:执行./nachos./nachos -f./nachos -D./nachos -cp test/small smallod DISK:查看DISK中的内容./nachos -l small./nachos -p small结论分析与体会:通过这次实验了解到nachos文件系统的基本构成和架构。

测试了nachos文件系统的基本功能检查了nachos文件系统中的模拟硬盘中的内容。

山东大学计算机学院操作系统实验报告

山东大学计算机学院操作系统实验报告

操作系统课程设计报告学院:计算机科学与技术学院专业:计算机科学与技术班级:20**级*班姓名:***学号:20**********目录一实验平台 (2)二Project1建立线程系统 (2)Task1.1实现KThread.join() (2)1.要求 (2)2.分析 (2)3.方案 (3)4.实现代码 (3)Task1.2利用中断提供原子性,直接实现条件变量 (4)1.要求 (4)2.分析 (5)3.方案 (5)4.实现代码 (5)Task1.3实现waitUntil (7)1.要求 (7)2.分析 (7)3.方案 (7)4.实现代码 (8)Task1.4用条件变量,不使用信号量,实现同步发送接收消息,speak,listen (10)1.要求 (10)2.分析 (10)3.方案 (11)4.实现代码 (11)Task1.5完成PriorityScheduler实现优先级调度 (13)1.要求 (13)2.分析 (13)3.方案 (14)4.实现代码 (14)Task1.6 (17)1.要求 (17)2.分析 (18)3.方案 (19)4.实现代码 (19)三Project2多道程序设计 (27)Task2.1 (27)1.要求 (27)2.分析 (28)3.方案 (28)4.实现代码 (31)Task2.2 (36)1.要求 (36)2.分析 (36)3.方案 (36)4.实现代码 (38)Task2.3 (43)1.要求 (43)2.分析 (43)3.方案 (44)4.实现代码 (45)Task2.4 (47)1.要求 (47)2.分析 (48)3.方案 (48)4.实现代码 (48)一实验平台开发语言:Java开发工具:Eclipse Luna操作系统:Ubuntu14.04二P roject1建立线程系统Task1.1实现KThread.join()1.要求实现Implement KThread.join()函数。

山东大学操作系统实验报告4进程同步实验

山东大学操作系统实验报告4进程同步实验

山东大学操作系统实验报告4进程同步实验计算机科学与技术学院实验报告实验题目:实验四、进程同步实验学号:日期:20120409 班级:计基地12 姓名:实验目的加深对并发协作进程同步与互斥概念的理解,观察和体验并发进程同步与互操作的效果,分析与研究经典进程同步与互斥问题的实际解决方案了 Linux 系统 IPC进程同步工具的用法,练习并发协作进程的同步与互斥操作的编与调试技术实验内容抽烟者问题假设一个系统中有三个抽烟者进程每个抽烟者不断地卷烟并抽烟抽烟者卷起并抽掉一颗烟需要有三种材料烟草纸和胶水一个抽烟者有烟草一个有纸,另一个有胶水。

系统中还有两个供应者进程,它们无限地供应所有种材料但每次仅轮流提供三种材料中的两种。

得到缺失的两种材料的抽烟者卷起并抽掉一颗烟后会发信号通知供应者让它继续提供另外的两种材料。

这过程重复进行请用以上介绍 IPC同步机制编程实现该问题要求的功能硬件环境@CPUi3-2350MIntel?Cor42.30GHz MobileIntel?Sandybridgex86/MMX/SSE24G内存3操作系统:20.1 GB磁盘:软件环境:ubuntu13.04实验步骤:(1)新建定义了producer和consumer 共用的文件。

ipc.h函数原型和变量的IPC.(2)新建ipc.c文件,编写producer和consumer共用的IPC的具体相应函数。

(3)新建Producer文件,首先定义producer的一些行为,利用系统调用建立共享内存区域,设定其长度并获取共享内存的首地址。

然后设定生产者互斥与同步的信号灯,并为他们设置相应的初值。

当有生产者进程在运行而其他生产者请求时,相应的信号灯就会阻止他,当共享内存区域已满时,信号等也会提示生产者不能再往共享内存中放入内容。

(4)新建Consumer文件,定义consumer的一些行为,利用系统调用来创建共享内存区域,并设定他的长度并获取共享内存的首地址。

(完整)山东大学操作系统实验一实验报告

(完整)山东大学操作系统实验一实验报告

(完整)山东大学操作系统实验一实验报告
编辑整理:
尊敬的读者朋友们:
这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布的,发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方,但是任然希望((完整)山东大学操作系统实验一实验报告)的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈,这将是我们进步的源泉,前进的动力。

本文可编辑可修改,如果觉得对您有帮助请收藏以便随时查阅,最后祝您生活愉快业绩进步,以下为(完整)山东大学操作系统实验一实验报告的全部内容。

操作系统课程设计实验报告
结论分析与体会:
通过这次实验,我熟悉了操作系统实验的环境,进一步了解了Nachos的构成,对我以后顺利熟练的完成操作系统实验有很大的帮助!。

山东大学操作系统实验报告完整版

山东大学操作系统实验报告完整版

山东大学操作系统实验报告HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】操作系统实验报告计算机科学与技术学院目录一、进程控制实验实验目的加深对于进程并发执行概念的理解。

实践并发进程的创建和控制方法。

观察和体验进程的动态特性。

进一步理解进程生命期期间创建、变换、撤销状态变换的过程。

掌握进程控制的方法,了解父子进程间的控制和协作关系。

练习 Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。

示例实验实验内容以下实验示例程序应实现一个类似shell 子命令的功能,它可以从执行程序中启动另一个新的子进程并执行一个新的命令和其并发执行。

实验演示结果独立实验实验内容参考以上示例程序中建立并发进程的方法,编写一个父子协作进程,父进程创建一个子进程并控制它每隔 3 秒显示一次当前目录中的文件名列表。

实验步骤算法设计通过进程间的通讯,先创建一个父进程一个子进程,父进程沉睡3秒,子进程作为当前父进程再次创建一个他的子进程,当前子进程执行显示当前目录文件列表功能,执行execve()方法后死亡。

While(1)在死循环里无限进行当前操作。

即达到父进程创建一个子进程并控制它每隔3秒显示一次当前目录中的文件名列表的要求。

开发调试过程打开一终端命令行窗体,新建一个文件夹,在该文件夹中建立名为的C 语言程序;再建立以下名为的 C 语言头文件;建立项目管理文件 Makefile;输入 make 命令编译连接生成可执行的 pctl 程序;执行 pctl 程序;再次执行带有子进程指定执行命令的 pctl 程序。

思考与分析1.反映的进程的特征和功能,在真实的操作系统中是怎样实现和反映出教材中讲解的进程的生命期、进程的实体和进程状态控制的。

对于进程概念和并发概念有哪些新的理解和认识子进程是如何创建和执行新程序的答:进程是一个可并发执行的程序在某数据集上的一次运行,是程序的一次运行过程。

计算机操作系统实验报告

计算机操作系统实验报告

计算机操作系统实验报告计算机操作系统实验报告引言:计算机操作系统作为计算机系统的核心组成部分,承担着管理和控制计算机硬件资源的重要任务。

通过实验,我们可以更好地理解操作系统的工作原理和功能,掌握操作系统的基本操作和管理技巧。

本文将结合实验结果,对操作系统实验进行总结和分析。

实验一:操作系统安装与配置在这个实验中,我们学习了操作系统的安装和配置过程。

通过选择合适的操作系统版本、设置分区和文件系统等步骤,成功地安装了操作系统。

同时,我们还学习了如何进行系统配置,包括网络设置、用户管理和软件安装等。

通过这个实验,我们对操作系统的基本安装和配置有了更深入的了解。

实验二:进程管理进程是操作系统中最基本的执行单位,也是操作系统资源管理的核心。

在这个实验中,我们学习了进程的创建、调度和终止等操作。

通过编写简单的程序,我们可以观察到进程的创建和调度过程,了解进程的状态转换和资源分配。

同时,我们还学习了进程间通信的方式,如共享内存和消息传递等。

通过这个实验,我们对进程管理有了更深入的理解。

实验三:内存管理内存管理是操作系统中重要的一部分,它负责管理和分配计算机的内存资源。

在这个实验中,我们学习了内存的分配和回收算法,如连续分配和非连续分配等。

通过编写程序,我们可以观察到内存的分配和回收过程,了解内存的管理策略和算法。

同时,我们还学习了虚拟内存的概念和实现原理,通过页面置换算法实现了虚拟内存的管理。

通过这个实验,我们对内存管理有了更深入的认识。

实验四:文件系统文件系统是操作系统中用于管理和存储文件的一种机制。

在这个实验中,我们学习了文件系统的基本操作和管理技巧。

通过创建文件、目录和链接等操作,我们可以更好地理解文件系统的结构和组织方式。

同时,我们还学习了文件的读写和权限管理等操作,通过编写程序实现了对文件的操作。

通过这个实验,我们对文件系统有了更深入的了解。

实验五:设备管理设备管理是操作系统中负责管理和控制计算机设备的一种机制。

山大操作系统实验-1教程文件

山大操作系统实验-1教程文件
山大操作系统实验-1
操作系统原理实验报告——实验一
张咪软件工程四班
一、实验目的
加深对于进程并发执行概念的理解。实践并发进/线程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法,了解父子进程间的控制和协作关系。练习Linux系统中进/线程创建与控制有关的系统调用的编程和调试技术。
signal(SIGINT,(sighandler_t)sigcat);
int count=0;
while(count<5){
if((pid1=fork())==0){
pause();
printf("%d This is child1 running\n",getpid());
status1=execve(args1[0],args1,NULL);
printf("%d Father: Child2 finnished\n",getpid());
count++;
if(kill(pid1,SIGINT)>=0){
waitpid(pid1,&status1,0);
printf("%d Father: Child1 finished.\n",getpid());
八、代码
#include"pro.h"
int main(int argc,char *argv[])
{
int i;
int pid1,pid2;
int status1,status2;
char *args1[]={"/bin/ls","-a",NULL};

山东大学操作系统试验-3

山东大学操作系统试验-3

软件学院实验报告实验题目:进程调度算法实验学号:20100030xxxx日期:2012-5-2班级:五班姓名:Email:实验目的:加深对进程调度概念的理解,体验进程调度机制的功能,了解Linux 系统中进程调度策略的使用方法。

练习进程调度算法的编程和调试技术。

硬件环境:IBM实验室计算机软件环境:eclipse gcc编译器Ubuntu-Linux操作系统Gnome桌面实验步骤:1.认真阅读试验指导书所给出的相关知识与示例程序,在此基础上分析独立试验要求,然后着手开始编写程序。

2.用eclipse新建一个c project。

3.新建source folder4.新建名为psched.c的C语言程序5.再建立以下名为psched.h的C语言头文件6.build项目,产生可运行的二进制文件。

7.对程序进行调试,排除bug。

8.进入终端,运行程序,结果如下图所示:源代码:#include"psched.h"int main(int argc,char*argv[]){int pid;//存放⼦进程号struct sched_param p1;//设置⼦进程调度策略时使⽤的数据结构struct sched_param p2;//设置⽗进程调度策略时使⽤的数据结构if((pid=fork())<0){perror("process not create");exit(EXIT_FAILURE);}else if(pid==0){signal(SIGTSTP,handler1);//注册⼀个处理ctrl+z的信号量,将优先级减⼀signal(SIGINT,handler3);//注册⼀个处理ctrl+c的信号量,什么也不做sleep(1);while(1){printf("Child PID=%d priority=%d policy is%d\n",getpid(),getpriority(PRIO_PROCESS,0),sched_getscheduler(getpid()));sleep(3);}}else{signal(SIGINT,handler2);//注册⼀个处理ctrl+c的信号量,将优先级加⼀signal(SIGTSTP,handler4);//注册⼀个处理ctrl+z的信号量,什么也不做sched_setscheduler(pid,SCHED_OTHER,&p1);sched_setscheduler(getpid(),SCHED_OTHER,&p2);setpriority(PRIO_PROCESS,pid,10);setpriority(PRIO_PROCESS,getpid(),10);sleep(1);while(1){printf("Parent PID=%d priority=%d policy is%d\n",getpid(),getpriority(PRIO_PROCESS,0),sched_getscheduler(getpid()));sleep(3);}}return EXIT_SUCCESS;}#include<stdio.h>#include<stdlib.h>#include<sched.h>#include<sys/time.h>#include<sys/resource.h>#include<unistd.h>#include<signal.h>//⼦进程处理信号SIGTSTP的⽅法,将优先级减⼀void handler1(){setpriority(PRIO_PROCESS,getpid(),getpriority(PRIO_PROCESS,0)-1); }//⽗进程处理信号SIGINT的⽅法,将优先级加⼀void handler2(){setpriority(PRIO_PROCESS,getpid(),getpriority(PRIO_PROCESS,0)+1);}void handler3(){}void handler4(){}结论分析与体会:通过编写进程调度试验,首先,我更加熟练了如何编写多进程程序,更加了解了型号量的注册和使用方法。

山东大学操作系统实验三实验报告

山东大学操作系统实验三实验报告

软件学院实验报告:3实验题目:信号量同步问题班级:2011级3班日期:2013-11-10 学号:201100300038 姓名:陶旭涛E-mail:1595242630@实验目的:1.在本次实验中,通过使用信号量,在原有的程序框架的基础上添加关键代码实现生产者/消费者同步问题。

2.深入理解Nachos的信号量的使用以及实现.3.理解生产者/消费者问题是如何用信号量实现的以及在Nachos中是如何创建线程,实现多线程。

硬件环境:Ubuntu12.04软件环境:Nachos,Mips,GDB实验步骤:1.首先初始化三个信号量,代码如下:mutex = new Semaphore("mutux",1);信号量初始化为1,才能起到加锁功能nfull = new Semaphore("full",0);nfull的大小在生产者没生产前为0 nempty = new Semaphore("empty",BUFF_SIZE);nempty的大小应该为buffer的大小2.首先考虑生产者进程,首先要查看buffer是否有空, nempty->P();if nempty>0,nempty=nempty -1,当对缓冲区操作时必须要加锁:mutex->P();加锁. 然后向ring中放入message信息,其次还要解锁mutex->V();解锁.最后通知消费者buffer有新信息, nfull->V();nfull=nfull+1;具体实现代码如下:3.考虑消费者进程,像生产者进程一样,查看buffer中是否有信息nfull->P();if nfull>0,nfull-1;取消息时也要上锁,即:mutex->P();加锁. 然后从ring buffer中取出信息;其次mutex->V();解锁;最后通知生产者bufferr有空nempty->V();nempty=nempty+1,具体代码如下:4.创建线程生成一个生产者的代码:producers[i] = new Thread(prod_names[i]);producers[i] -> Fork(Producer,i);4.创建线程生成一个消费者的代码:producers[i] = new Thread(prod_names[i]);producers[i] -> Fork(Producer,i);关键代码:voidProducer(_int which){int num;slot *message = new slot(0,0);for (num = 0; num < N_MESSG ; num++) { //这是消息创建的代码m essage->thread_id=which;message->value=num;//p,v 操作nempty->P();mutex->P();ring->Put(message);//p,v 操作mutex->V();nfull->V();}}voidConsumer(_int which){char str[MAXLEN];char fname[LINELEN];int fd;slot *message = new slot(0,0);sprintf(fname, "tmp_%d", which);// create a file. Note that this is a UNIX system call.if ( (fd = creat(fname, 0600) ) == -1){perror("creat: file create failed");Exit(1);}for (; ; ) {// p,v,操作n full->P();m utex->P();ring->Get(message);// p,v,操作mutex->V();nempty->V();// form a string to record the messagesprintf(str,"producer id --> %d; Message number --> %d;\n", message->thread_id,message->value);//把信息写入文件if ( write(fd, str, strlen(str)) == -1 ) {perror("write: write failed");Exit(1);}}}//---------------------------------------------------------------------- // ProdCons// 初始化信号量以及需要的生产者消费者线程//----------------------------------------------------------------------voidProdCons(){int i;DEBUG('t', "Entering ProdCons");// 初始化信号量,包括一个访问互斥信号量,初值为1;//一个nempty信号量,初值为缓冲区的大小//一个nfull的信号量,初值为0mutex=new Semaphore("mutex",1);nempty=new Semaphore("nempty",BUFF_SIZE);nfull=new Semaphore("nfull",0);// 新建一个缓冲区ring=new Ring(BUFF_SIZE+1);// create and fork N_PROD of producer threadsfor (i=0; i < N_PROD; i++){// this statemet is to form a string to be used as the name for// produder i.sprintf(prod_names[i], "producer_%d", i);// 创建生产者线程producers[i]=new Thread(prod_names[i]);producers[i]->Fork(Producer,i);};// create and fork N_CONS of consumer threadsfor (i=0; i < N_CONS; i++){// this statemet is to form a string to be used as the name for// consumer i.sprintf(cons_names[i], "consumer_%d", i);//创建消费者线程consumers[i]=new Thread(cons_names[i]);consumers[i]->Fork(Consumer,i);};}调试记录:在源代码中exit(0)没有大写,调试过程发现了这个问题改正,在使用Linux系统调用写入文件时,有一个头文件没有引入,因而需要修改#include <stdio.h>#include "copyright.h"#include "system.h"#include <unistd.h>#include <fcntl.h>而且对于新添加的头文件的方法其中源文件使用的一个方法是废弃的,所以改成相应的方法write(fd, str, strlen(str)),实验结果:生成两个文件分别代表两个消费者取得的产品的记录。

山东大学操作系统实验七实验报告

山东大学操作系统实验七实验报告

计算机科学与技术学院实验报告
8 }
在文件../test/第5行上的语句Exec是一条Nachos的系统功能调用,它的功能为装入并执行以其参数为名的可执行文件,即创建一个新的用户进程。

假设我们先执行../test/ 程序,则../test/ 会在它还没有执行结束时又装入并执行另外一个程序,并与它同时驻留内存.
pageTable[i].physicalPage=usermap-->Find();避免从头开始物理存储覆盖了前一个用户程序的内存内容
利用Nachos在../userprog/ 中文件定义的Bitmap类。

利用bitmap记录和申请内存物理帧,使不同的程序装入到不同的物理空间中去,下面是对新的内存分配存储算法,改进了对多个用户程序的同时进驻内存的支持
这是对BitMap的代码修改,每次分配的时候要找到bitmap中的空闲页进行分配,而不能从0页开始分配在AddressSpace类中声明bitmap对象
static BitMap *mbitmap=new BitMap(NumPhysPages);
运行./nachos –x ../test/
结论分析与体会:
nachos无法运行多个用户程序的原因在于物理页的分配,那么改变物理页的分配,使多个程序的物理页不会相互覆盖,每个程序都能分配到对应的独立的物理页,那么不就可以同时执行多个用户程序了吗。

物理页的分配算法在BitMap类中有实现,使用一个数组作为物理页的数据结构。

在给用户程序分配物理页时,不再使用与逻辑页相同的数值,而是使用Find()方法查找下一个可用的物理页。

山东大学操作系统实验六实验报告

山东大学操作系统实验六实验报告

计算机科学与技术学院实验报告实验题目: Nachos User Programs and System学号: 201100300038 Calls日期:2013-11-27 班级: 11级03 姓名:陶旭涛Email: 1595242630@实验目的:实验并熟悉Nachos中的用户程序,你需要实现Nachos系统调用的代码。

其目的是理解如何将用户进程启动通过系统调用与操作系统内核如何将用户进程交互硬件环境:Mem:3.9GDisk:15.5 GB软件环境:System:ubuntu12.04LST i386gcc: (Ubuntu 4.6.3-1ubuntu5) 4.6.3nachos system实验步骤:1: ../test 中现有 5 个 C 语言用户源程序,可以通过 make 命令一次性编译连接生成它们的可执行文件和其在该目录中的符号链接2:进入../userprog 目录,使用 make 命令生成带有基本内存管理功能的 Nachos 内核。

现在我们就可以使用新的内核执行用户程序了。

例如,为了执行../test 目录中的 halt.noff 程序,可以输入命令:$./nachos –x ../test/halt.noff$./nachos –d ../test/halt.noff3:为了能够了解 Nachos 中多用户程序驻留内存的情况,可以在 AssSpace类中增加以下打印成员函数 Print:4:最小的用户程序 halt.c 会占用 10 页的内存空间。

如果你想验证系统能否分配更多的内存页,可以在用户程序中说明一些较大的数组。

例如,修改 halt.c,在其中说明一个静态数组 a:#include "syscall.h"static int a[40];intmain(){Halt();/* not reached */}再次执行../test 目录中的 make,并再次进入../userprog 目录,使用 make 命令生成带有输出用户程序页分配信息的 Nachos 内核。

操作系统实验报告

操作系统实验报告

设计一读者写者问题实习环境:系统为Windows XP + VC 6.0一、实验目的:1、加深对进程概念的理解,明确进程和程序的区别,进一步认识并发执行的实质;2、理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。

二、设计要求在Windows XP下创建一个控制台进程,该进程应包含n个线程。

用这n个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的操作限制(包括读者优先和写者优先):1)写-写互斥,即不能有两个写者同时进行写操作。

2)读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

3)读-读互斥,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源,则该读者必须等到没有写者出于等待状态后才能开始读操作。

测试文件格式说明,下面是一个测试数据文件的例子:1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 36 R 15 47 R 15 4三、设计说明1、读者优先指除非有写者在写文件,否则读者不需要等待。

所以可以用一个整形变量readnum记录当前的读者数目,用于确定是否需要唤醒正在等待的写者进程(当readnum==读者人数时,表明所有的读者读完,需要唤醒写者等待队列中的第一个写者)。

每一个读者开始读文件时,必须修改readnum变量。

因此需要一个互斥对象rnum[]来实现对全局变量readnum修改时的互斥。

另外,为了实现写写互斥,需要增加一个临界区对象wstate。

当写者发出写请求时,必须申请临界区对象的所有权。

通过这种方法,也可以实现读写互斥,当readnum=2时(即第一个读者到来时),读者进程也必须申请临界区对象的所有权。

高等学校计算机操作系统实验报告最终答案

高等学校计算机操作系统实验报告最终答案

实验1进程的描述与控制Windows 2000编程(实验估计时间:100分钟)1.1 背景知识Windows 2000 可以识别的应用程序包括控制台应用程序、GUI应用程序和服务应用程序。

控制台应用程序可以创建GUI,GUI应用程序可以作为服务来运行,服务也可以向标准的输出流写入数据。

不同类型应用程序间的惟一重要区别是其启动方法。

Windows 2000是以NT技术构建的,它提供了创建控制台应用程序的能力,使用户可以利用标准的C++工具,如iostream库中的cout和cin对象,来创建小型应用程序。

当系统运行时,Windows 2000的服务通常要向系统用户提供所需功能。

服务应用程序类型需要ServiceMail()函数,由服务控制管理器(SCM)加以调用。

SCM是操作系统的集成部分,负责响应系统启动以开始服务、指导用户控制或从另一个服务中来的请求。

其本身负责使应用程序的行为像一个服务,通常,服务登录到特殊的LocalSystem账号下,此账号具有与开发人员创建的服务不同的权限。

当C++编译器创建可执行程序时,编译器将源代码编译成OBJ文件,然后将其与标准库相链接。

产生的EXE文件是装载器指令、机器指令和应用程序的数据的集合。

装载器指令告诉系统从哪里装载机器代码。

另一个装载器指令告诉系统从哪里开始执行进程的主线程。

在进行某些设置后,进入开发者提供的main()、Servicemain()或WinMain()函数的低级入口点。

机器代码中包括控制逻辑,它所做的事包括跳转到Windows API函数,进行计算或向磁盘写入数据等。

Windows允许开发人员将大型应用程序分为较小的、互相有关系的服务模块,即动态链接库(DLL)代码块,在其中包含应用程序所使用的机器代码和应用程序的数据。

1.2 实验目的通过对Windows 2000编程,进一步熟悉操作系统的基本概念,较好地理解Windows 2000的结构。

操作系统实验报告 完全版

操作系统实验报告 完全版

《计算机操作系统》实验报告班级:姓名:学号:实验一进程控制与描述一、实验目的通过对Windows 2000编程,进一步熟悉操作系统的基本概念,较好地理解Windows 2000的结构。

通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解Windows 2000中进程的“一生”。

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

三、实验内容和步骤第一部分:程序1-1Windows 2000 的GUI 应用程序Windows 2000 Professional下的GUI应用程序,使用Visual C++编译器创建一个GUI 应用程序,代码中包括了WinMain()方法,该方法GUI类型的应用程序的标准入口点。

# include <windows.h># pragma comment(lib, “user32.lib” )int APIENTRY WinMain(HINSTANCE /* hInstance */ ,HINSTANCE /* hPrevInstance */,LPSTR /* lpCmdLine */,int /* nCmdShow */ ){:: MessageBox(NULL,“hello, Windows 2000” ,“Greetings”,MB_OK) ;return(0) ; }在程序1-1的GUI应用程序中,首先需要Windows.h头文件,以便获得传送给WinMain() 和MessageBox() API函数的数据类型定义。

接着的pragma指令指示编译器/连接器找到User32.LIB库文件并将其与产生的EXE文件连接起来。

这样就可以运行简单的命令行命令CL MsgBox.CPP来创建这一应用程序,如果没有pragma指令,则MessageBox() API函数就成为未定义的了。

山东大学操作系统实验五

山东大学操作系统实验五

软件学院操作系统实验报告实验题目:实验五、进程互斥实验学号:201100300124日期:2013年05月20日班级:5班姓名:韩俊晓Email:hanjunxiao188@实验目的:进一步研究和实践操作系统中关于并发进程同步与互斥操作的一些经典问题的解法,加深对于非对称性互斥问题有关概念的理解。

观察和体验非对称性互斥问题的并发控制方法。

进一步了解Linux系统中IPC进程同步工具的用法,训练解决对该类问题的实际编程、调试和分析问题的能力。

实验要求:理发店问题:假设理发店的理发室中有3个理发椅子和3个理发师,有一个可容纳4个顾客坐等理发的沙发。

此外还有一间等候室,可容纳13位顾客等候进入理发室。

顾客如果发现理发店中顾客已满(超过20人),就不进入理发店。

在理发店内,理发师一旦有空就为坐在沙发上等待时间最长的顾客理发,同时空出的沙发让在等候室中等待时间最长的的顾客就坐。

顾客理完发后,可向任何一位理发师付款。

但理发店只有一本现金登记册,在任一时刻只能记录一个顾客的付款。

理发师在没有顾客的时候就坐在理发椅子上睡眠。

理发师的时间就用在理发、收款、睡眠上。

请利用linux系统提供的IPC进程通信机制实验并实现理发店问题的一个解法。

硬件环境:实验室计算机软件环境:Ubuntu08.4-Linux操作系统BASH_VERSION='3.2.33(1)-releasegcc version 4.1.2gedit 2.18.2OpenOffice 2.3实验步骤:实验思路:(1)对于理发师进程可以创建两个子进程,这样父子进程就构成了三个理发师,控制对顾客的理发过程,同时对账本采用互斥记账方法(2)对于消费者进程,则创建四个消息队列,分别为sofa_quest,sofa_respond,wait_quest,wait_respond,分别响应不同的信号请求,打印不同的信息。

1.实验说明:在linux系统中可以利用进程间通信(interprocess communication )IPC 中的3个对象:共享内存、信号灯数组、消息队列,来解决协作并发进程间的同步与互斥的问题。

山大操作系统实验

山大操作系统实验

⼭⼤操作系统实验操作系统原理实验报告——实验⼀张咪软件⼯程四班⼀、实验⽬的加深对于进程并发执⾏概念的理解。

实践并发进/线程的创建和控制⽅法。

观察和体验进程的动态特性。

进⼀步理解进程⽣命期期间创建、变换、撤销状态变换的过程。

掌握进程控制的⽅法,了解⽗⼦进程间的控制和协作关系。

练习Linux系统中进/线程创建与控制有关的系统调⽤的编程和调试技术。

⼆、实验要求编写⼀个多进程并发执⾏程序。

⽗进程每隔3秒重复建⽴两个⼦进程,⾸先创建的让其执⾏ls命令,之后创建执⾏让其执⾏ps 命令,并控制ps命令总在ls命令之前执⾏。

三、实验软硬件环境实验环境均为Linux操作系统,开发⼯具为gcc和g++。

四、实验思路调⽤fock()创建⼦进程。

创建键盘中断信号后,使⽤pause()可以暂停⼦进程执⾏,继续创建新的⼦进程。

⼦进程并发执⾏⼦进程可以⾸先通过键盘中断信号唤醒⼦进程。

通过exec()调⽤族装⼊⼀个新的执⾏程序。

在建⽴⼦进程2并且唤醒⼦进程1后⼦进程sleep(seconds = 5)。

这样就可以先执⾏ps后执⾏ls。

最后就是⽗进程的结束,程序结束。

六、调试排错1、⾸先遇到的问题是,对linux的操作不熟悉,不太明⽩makefile怎么使⽤,直接⽤了gcc2、在创建多个⼦进程上遇到了问题,在fock()后⼜直接跟了⼀个fork(),这样创建的⼦进程是⼦进程的⼦进程,⽽不是⽗进程创建的第⼆个⼦进程。

所以应该在else语句块后⾯,也就是主进程执⾏段继续创建。

⼀般情况下,fork()按如下规则编程:main(){ pid_t pid;pid=fork();if(pid<0) { // 建⽴⼦进程失败{ printf("Create Process fail!\n");exit(EXIT_FAILURE); }if (pid = = 0)//⼦进程代码;//如果需要创建⼦进程,可以按该⽅法嵌套else//⽗进程代码//如果需要创建⼦进程,可以按该⽅法嵌套}3、后来⽗进程与⼦进程⽆法重复建⽴,执⾏⼀次就结束了,⼜加了⼀个while循环实现重复建⽴,但⽆法退出,⼀直执⾏。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

操作系统实验报告——实验一实验题目:Synchronization Using Semaphore 日期:2013.12班级:计算机11级2班姓名:实验目标:在这个实验中,需要使用系统提供的同步信号量来实现生产者/消费者问题。

完成这一部分后,将会了解Nachos的信号量实现以及如何用信号量来实现生产者/消费者问题,同时了解如何在Nachos中创建多线程。

实验环境:ubuntu-12.04.1-desktop-i386实验分析:要实现生产者消费者问题,要使用信号量来控制资源,在threads/ 文件中实现了信号量。

设置访问的共享缓冲区,生产者每次往缓冲区中放入数据,修改信号量,一旦缓冲区数据满了以后,生产者需要等待缓冲区不满才能再放入;而消费者每次从缓冲区中取走一个资源,如果缓冲区为空,必须进入等待,若有多个生产者/消费者同时对共享的缓冲区进行操作,除了考虑生产者/消费者之间的同步问题还需要考虑生产者之间和消费者之间的互斥问题,必须保证同一时间只有一个生产者(消费者)访问缓冲区。

综上:解决生产者/消费者的示意图为:-生产者-消费者P(empty) P(full)P(mutex) P(mutex)... ...生产消费... ...V(mutex) V(mutex)V(full) V(empty)其中,empty,full,mutex这三个信号量分别用来实现缓冲区为空,缓冲区为前满以及互斥的要求。

其中信号量的定义在thread/以及synch.h中其中p和v操作分别如下:voidSemaphore::P(){IntStatus oldLevel = interrupt->SetLevel(IntOff); // disable interruptswhile (value == 0) { // semaphore not availablequeue->Append((void *)currentThread); // so go to sleepcurrentThread->Sleep();}value--; // semaphore available,// consume its value(void) interrupt->SetLevel(oldLevel); // re-enable interrupts}//----------------------------------------------------------------------// Semaphore::V// Increment semaphore value, waking up a waiter if necessary.// As with P(), this operation must be atomic, so we need to disable// interrupts. Scheduler::ReadyToRun() assumes that threads// are disabled when it is called.//----------------------------------------------------------------------voidSemaphore::V(){Thread *thread;IntStatus oldLevel = interrupt->SetLevel(IntOff);thread = (Thread *)queue->Remove();if (thread != NULL) // make thread ready, consuming the V immediatelyscheduler->ReadyToRun(thread);value++;(void) interrupt->SetLevel(oldLevel);}本实验主要修改的文件为:prodcons++.cc实验步骤:本实验主要就是根据提示将prodcons++.cc中缺少的代码补充完整。

首先是生产者调用的producer方法,nempty->P(); // Put the code for //synchronization before ring->Put(message) here.mutex->P(); // ...ring->Put(message);mutex->V(); // Put the //code for synchronization after ring->Put(message) here.nfull->V(); //之后是消费者调用的consumer方法:nfull->P();// Put the code for synchronization before //ring->Get(message) here.mutex->P();// ...ring->Get(message);mutex->V();// Put the code for synchronization after//ring->Get(message) here.nempty->V();// ...最后就是各信号量以及生产者/消费者线程的声明:voidProdCons(){int i;DEBUG('t', "Entering ProdCons");nempty=new Semaphore("empty",BUFF_SIZE); //声明empty信号量nfull=new Semaphore("full",0); //声明full信号量mutex=new Semaphore("mutex",1);//声明互斥信号量// Put the code to construct all the semaphores here.// ....ring=new Ring(BUFF_SIZE);// Put the code to construct a ring buffer object with size//BUFF_SIZE here.// ...//*producers[N_PROD] = new Thread();// create and fork N_PROD of producer threadsfor (i=0; i < N_PROD; i++){// this statemet is to form a string to be used as the name for // produder i.sprintf(prod_names[i], "producer_%d", i);producers[i] = new Thread(prod_names[i]);//生产者线程初始化// Put the code to create and fork a new producer thread using // the name in prod_names[i] and// integer i as the argument of function "Producer"// ...producers[i]->Fork(Producer,i); //挂起生产者线程};// create and fork N_CONS of consumer threadsfor (i=0; i < N_CONS; i++){// this statemet is to form a string to be used as the name for // consumer i.sprintf(cons_names[i], "consumer_%d", i);consumers[i] = new Thread(cons_names[i]);//消费者线程初始化// Put the code to create and fork a new consumer thread using// the name in cons_names[i] and// integer i as the argument of function "Consumer"// ...consumers[i]->Fork(Consumer,i); //挂起消费者线程};}调试记录:不管设置几个生产者,几个消费者,每次的输出结果基本一致。

实验结果:最后执行完后输出得到tmp_0和tmp_1文件(由于这里消费者数量为2,所以有2个tmp文件)tmp_0:producer id --> 0; Message number --> 0;producer id --> 1; Message number --> 0;producer id --> 0; Message number --> 2;producer id --> 2; Message number --> 1;tmp_1:producer id --> 1; Message number --> 1;producer id --> 0; Message number --> 1;producer id --> 0; Message number --> 3;producer id --> 1; Message number --> 2;producer id --> 2; Message number --> 0;producer id --> 2; Message number --> 2;producer id --> 2; Message number --> 3;producer id --> 1; Message number --> 3;分析结果:对于同一个消费者,相同的生产者,生产号是递增的,说明取的时候是按照顺序的。

结论分析与体会:通过这个实验对生产者/消费者问题有了更深入的了解,之前只是一个生产者--一个消费者模式或者一个生产者--多个消费者模式,而多个生产者--多个消费者模式不仅仅需要考虑生产者/消费者之间的同步问题,同时生产者之间,消费者之间的互斥问题也同样需要考虑。

相关文档
最新文档