东北大学操作系统实验报告1-2017
《操作系统》实验报告(一)
《操作系统》实验报告（一）Linux基本操作与编程（验证性 2学时）1、实验目的：1）熟悉Linux操作系统的环境和使用。
2）* 了解LINUX系统的安装过程。
（注：＊表示可选择）3）掌握Linux环境下的命令操作。
2、实验内容：（1）完成LINUX系统的登录，启动终端。
进行下列操作并记录结果(要求：结果以屏幕截图表示)。
1）运行pwd命令，确定你当前的工作目录。
2）利用以下命令显示当前工作目录的内容： ls –l3）运行以下命令： ls –al4）使用mkdir命令建立一个子目录subdir。
5）使用cd命令，将工作目录改到根目录（/）上。
6）使用ls-l命令列出/dev的内容。
7）使用不带参数的命令cd改变目录，然后用pwd命令确定你当前的工作目录是哪里？8）使用命令cd../..，你将工作目录移到什么地方?（2）在LINUX下查看你的文件。
1利用cd命令，将工作目录改到你的主目录上。
2）将工作目录改到你的子目录subdir，然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中。
3）使用cat命令查看file1文件的内容。
4）利用man命令显示date命令的用法： man date5）将date命令的用法附加到文件file1的后面：man date >> file16）利用cat命令显示文件file1的内容。
7）利用ls -l file1命令列出文件file1的较详细的信息。
运行ls -l/bin命令显示目录的内容。
8）利用ls -l/bin|more命令行分屏显示/bin目录的内容。
9）利用cp file1 fa命令生成文件file1的副本。
然后利用ls -l命令查看工作目录的内容。
10）用cd命令返回你的主目录，输入命令ls –l后，解释屏幕显示的第一列内容的含义。
- 为文件类型（（3）编写能输出“Hello world!”问候语的C程序，并在终端中编译、执行。
东北大学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地址、子网掩码、网关等参数的设置。
(完整word版)操作系统实验报告.实验一 WINDOWS进程初识
操作系统教程实验指导书实验一WINDOWS进程初识1、实验目的（1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。
（2）掌握WINDOWS API的使用方法。
（3）编写测试程序，理解用户态运行和核心态运行。
2、实验内容和步骤（1）编写基本的Win32 Consol Application步骤1：登录进入Windows，启动VC++ 6.0。
步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。
创建一个新的控制台应用程序工程。
步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。
步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。
编译成可执行文件。
步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe运行结果 (如果运行不成功，则可能的原因是什么？) ：答：运行成功，结果：（2）计算进程在核心态运行和用户态运行的时间步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。
步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。
步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。
在这个实验中，我们使用C+＋编写程序来创建和管理进程。
通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。
首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。
然后，使用等待函数来等待子进程的结束，并获取其返回值。
在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。
2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。
在这个实验中，我们研究了动态内存分配和释放的机制。
使用 C+＋中的 new 和 delete 操作符来分配和释放内存。
通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。
同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。
通过模拟内存访问过程，理解了页表的作用和地址转换的过程。
3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。
在这个实验中，我们对文件的创建、读写和删除进行了操作。
使用 C+＋的文件流操作来实现对文件的读写。
通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。
此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。
4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。
东北大学操作系统实验报告
/* This program simulates two processes, producer which */
/* continues to produce message and put it into a buffer */
cout << "2:running-->ready" << endl;
cout << "3:running-->blocked" << endl;
cout << "4:blocked-->ready" << endl;
cout << "5:new-->ready" << endl;
cout << "6:running-->exit" << endl;
C语言编辑、编译
四、实验结果（截图）
ls mkdir:
cd:
rmdir:
实验二进程状态
一、实验目的
自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容 、组织的变化，理解进程与其PCB间的一一对应关系。
二、实验原理
1.进程在内存中存在三种基本状态：就绪态、执行态、阻塞态
cout << "Status contains r1(running),r2(ready) and b(blocked)." << endl;
cin >> sta;
操作系统 实验报告
操作系统实验报告操作系统实验报告引言：操作系统是计算机系统中最重要的软件之一，它负责管理计算机硬件资源，并提供程序运行环境。
操作系统的设计和实现是计算机科学领域的重要研究方向之一。
本篇实验报告将介绍我们在操作系统实验中所进行的实践和实验结果。
一、实验目的我们的实验目的是通过实践操作系统的基本功能，深入理解操作系统的原理和实现方式。
具体来说，我们的实验目标包括：1. 学习并掌握操作系统的基本概念和原理；2. 理解操作系统与硬件之间的交互过程；3. 实践操作系统的进程管理、内存管理和文件系统等功能；4. 分析操作系统的性能和优化策略。
二、实验环境我们使用了一台配置较高的计算机作为实验环境，该计算机配备了一块主频为2.5GHz的多核处理器、8GB内存和500GB硬盘。
我们选择了一款常见的操作系统作为实验平台，以便于进行实验和调试。
三、实验过程1. 进程管理在进程管理实验中，我们实现了进程的创建、调度和终止等功能。
首先，我们编写了一个简单的程序，用于创建多个进程并进行调度。
然后，我们通过观察进程的执行顺序和时间片分配情况，分析操作系统的调度算法对系统性能的影响。
2. 内存管理在内存管理实验中，我们实现了内存的分配和回收等功能。
我们编写了一个模拟程序，用于模拟内存的分配和释放过程。
通过观察内存分配的效率和内存碎片的情况，我们评估了不同的内存管理算法的性能。
3. 文件系统在文件系统实验中，我们实现了文件的创建、读写和删除等功能。
我们编写了一个简单的文件操作程序，用于测试文件系统的性能和可靠性。
通过观察文件系统的读写速度和文件恢复的效果，我们评估了不同的文件系统实现方式的优劣。
四、实验结果通过实验，我们获得了以下结果：1. 进程管理实验中，我们发现不同的调度算法对系统性能的影响差异较大。
短作业优先算法在短时间内能够提高系统的响应速度，而时间片轮转算法则能够保证公平性。
2. 内存管理实验中，我们发现不同的内存管理算法对内存利用率和碎片情况有很大的影响。
计算机操作系统实训报告2017
}
}
void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float
zztime,float dqzztime,float totalzztime,float totaldqzztime,int N)
3 程序代码
#include <cstdlib> #include <iostream> #include<iomanip> using namespace std; struct fcfs{ //先来先服务算法从这里开始
1
实训一 先进先出调度算法实现
char name[10];
float arrivetime;
{
float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0,tota
lzztime=0,totaldqzztime=0;
sort(p,N);
deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,totalzztime,totaldq
完成时间
周转时间
带权周
ห้องสมุดไป่ตู้
for(k=0;k<=N-1;k++)
{
2
实训一 先进先出调度算法实现
printf("%s\t%-.2f\t %-.2f\t %-.2f\t%-.2f\t%-.2f\t\t%-.2f\t\t%-.2f\t\t%-.2f\n", p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].d qzztime,totalzztime/N,totaldqzztime/N);
os实验报告22153303
计算机操作系统实验报告学 号： 2153303姓 名：王咏毅提交日期：2017-11-2成 绩：东北大学秦皇岛分校计算机与通信工程学院操作系统 实验报告 实验2使用动态分区分配方式的模拟1 实验目的（1）了解动态分区分配方式中使用的数据结构和分配算法（2）加深对动态分区存储管理方式及其实现过程的理解。
2 实验内容（1）分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。
其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。
（2）假设初始状态下，可用的内存空间为 1280KB，并有下列的请求序列：•作业1申请130KB。
•作业2申请60KB。
•作业3申请100KB。
•作业2释放60KB。
•作业4申请200KB。
•作业3释放100KB。
•作业1释放130KB。
•作业5申请140KB。
•作业6申请60KB。
•作业7申请50KB。
•作业6释放60KB。
分别采用首次适应算法和最佳适应算法，对内存块进行分配和回收，要求每次分配和回收后显示出空闲分区链的情况。
3 实验结果（给出编写的程序源代码和运行结果的截图）#include<stdio.h>#include<stdlib.h>struct node //空闲分区链结点的定义{node *before;node *after;int size; intaddress; intstate; };node L; structusenode{usenode *next;int num;int add;intsize; }U,*n;东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告void Init() //空闲分区链的初始化{node *p;p=(node *)malloc(sizeof(node)); p->before=&L;p->after=NULL;p->size=640; p->address=0; p->state=0;L.after=p;L.before=NULL;L.size=0;U.next=NULL;n=&U;}node *search(int a){node *p=L.after;if(p==NULL){printf("没有空闲的区域!");p=NULL;return p;}else{while(p!=NULL && a>p->size) p=p->after;if(p==NULL){printf("没有找到合适的空闲空间!"); p=NULL;东北大学秦皇岛分校计算机与通信工程学院return p;}elsereturn p;}}void recovery(int a,int b) //内存回收算法{node *c,*s,*r=L.after; node*d=L.after,*e; usenode*k=U.next,*h=&U;while(k!=NULL && a!=k->num){h=k; k=k->next;}if(k==NULL)printf("没有找到这样的作业!");else{h->next=k->next;if(h->next==NULL)n=h;}while(r!=NULL) //若回收得到的空闲块的前方有空闲块合并此空闲块{if(k->add==r->address+r->size){r->size=r->size+k->size;break;东北大学秦皇岛分校计算机与通信工程学院}else r=r->after;}if(r==NULL) //若回收得到的空闲块的后面有空闲块合并此空闲块{r=L.after;while(r!=NULL){if(k->add+k->size==r->address){r->address=k->add; r->size=r->size+k->size;break;}else r=r->after;}}while(d!=NULL) //保证空闲链表中没有相邻的空闲空间{if(d->after!=NULL)e=d->after;elsebreak;if(d->address+d->size==e->address){d->after=e->after; while(e->after!=NULL) e->after->before=d; d->size=d->size+e->size;东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告free(e);break;}else d=d->after;}if(r==NULL){r=L.after;c=(node *)malloc(sizeof(node)); c->size=b;c->address=k->add;if(L.after==NULL){c->after=L.after; c->before=&L;L.after=c;}else{r=L.after;while(r!=NULL){if(r->address>c->address){c->after=r; c->before=r->before; r->before->after=c; r->before=c; free(k);return;}东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告elser=r->after;}}}free(k);}void alloc(int a ,int b) //分配内存算法{node *p,*q=L.after;usenode *m;p=search(b);if(p==NULL) return;m=(usenode *)malloc(sizeof(usenode));//生成一个被占用链表的结点, 并插入到该链表的尾部m->add=p->address;m->size=b; m->num=a; m->next=n->next; n->next=m;n=m; //保证 n 始终指向被占用链表的尾部，方便以后新生成结点的插入if(p->size>b) //如果申请空间的大小小于找到空闲空间的大小的处理{p->size=p->size-b; p->address=p->address+b;}else //如果申请空间的大小等于找到空闲空间的大小的处理{p->before->after=p->after;东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告if(p->after!=NULL)p->after->before=p->before;free(p);}}void sort() //对空闲链表进行排序{int max;node *p,*q,*r,*s;node a; p=L.after;while(p!=NULL) //让指针 q 指向链表的最后一个结点{q=p; p=p->after;}if(L.after->after==NULL)return;else{while(p!=q){s=r=p=L.after;max=r->size;while(s!=q->after){if(s->size>max){max=s->size;r=s; s=s->after;东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告}else s=s->after;}a.size=q->size;a.address=q->address; q->size=r->size; q->address=r->address; r->size=a.size; r->address=a.address; if(q->before->before==&L)return;else q=q->before;}}}void Print(){node *p=L.after;usenode *q=U.next;int i=1;printf("空闲区域列表:\n");printf("FREEID address size\n"); while(p!=NULL){printf("%-10d",i);printf("%-10d",p->address); printf("%d\n",p->size); p=p->after;i++;}if(q==NULL)东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告return;else{printf("已分配区域列表:\n"); printf("WORKID address size\n"); while(q!=NULL){printf("%-10d",q->num); printf("%-10d",q->add);printf("%d\n",q->size);q=q->next;}}}void firstfit() //首次适应算法{int a,b,i;Init();Print();while(1){printf("1、申请空间 2、释放空间 3、退出首次适应算法请输入你的选择:");scanf("%d",&i);switch(i){case 1:{printf("请输入申请空间的作业号:"); scanf("%d",&a);printf("请输入申请空间的大小:"); scanf("%d",&b);alloc(a,b);Print();break;}东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告case 2:{printf("请输入释放空间的作业号:"); scanf("%d",&a);printf("请输入释放空间的大小:"); scanf("%d",&b);recovery(a,b);Print();break;}case 3:printf("\n");return;}}}void bestfit(){int a,b,i;Init();Print();while(1){printf("1、申请空间 2、释放空间3、退出最佳适应算法请输入你的选择:"); scanf("%d",&i);switch(i){case 1:{printf("请输入申请空间的作业号:"); scanf("%d",&a);printf("请输入申请空间的大小:"); scanf("%d",&b);alloc(a,b);sort();Print();东北大学秦皇岛分校计算机与通信工程学院文档来源为:从网络收集整理.word版本可编辑.欢迎下载支持.操作系统 实验报告break;}case 2:{printf("请输入释放空间的作业号:"); scanf("%d",&a);printf("请输入释放空间的大小:"); scanf("%d",&b);recovery(a,b);sort();Print();break;}case 3:printf("\n");return;}}}int main(void){int i;while(1){printf("1、首次适应算法 2、最佳适应算法 3、退出请输入你的选择:"); scanf("%d",&i); switch(i){case 1:firstfit();break; case 2:bestfit();break; case 3:return 0; }}}东北大学秦皇岛分校计算机与通信工程学院东北大学秦皇岛分校计算机与通信工程学院东北大学秦皇岛分校计算机与通信工程学院操作系统 实验报告思考题（1）首次适应分配算法():对空闲分区表记录的要求是按地址递增的顺序排列的，每次分配时，总是从第1条记录开始顺序查找空闲分区表，找到第一个能满足作业长度要求的空闲区，分割这个空闲区，一部分分配给作业，另一部分仍为空闲区。
操作系统实验报告
命令名
功能
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);
东北大学操作系统实验一报告
操作系统实验报告班级物联网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 [选项] 源文件或目录目标文件或目录.mv命令部分选项含义命令格式：rm [选项] 文件…rm命令部分选项含义能是当前目录中已有的目录命令格式：mkdir [选项] 目录..mkdir命令部分选项含义命令格式：cd [目录名]。
操作系统实验报告
操作系统实验报告实验目的本次实验的主要目的是通过自主设计和编写一个简单的操作系统内核，进一步加深对操作系统相关理论知识的理解和实践能力的锻炼。
同时，通过实际操作和调试，了解操作系统的基本功能和特性，提高对操作系统工作原理的深入认识。
实验环境在进行本次实验之前，我们需要先搭建实验环境。
以下是本次实验所需的环境配置： - 操作系统：Windows或Linux - 开发工具：gcc编译工具链、nasm汇编器、Bochs模拟器实验过程1.机器启动过程–计算机的启动过程主要包括电源启动、BIOS自检、加载操作系统等步骤。
–在本次实验中，我们需要自行编写一个简单的引导扇区程序，将其写入磁盘的MBR（Master Boot Record）位置，以完成系统的启动。
2.引导扇区编写与加载–引导扇区是计算机启动的关键部分，它的主要任务是加载操作系统的内核到内存中，并将控制权转交给内核。
–在本次实验中，我们可以使用汇编语言编写一个简单的引导扇区程序，并将其加载到MBR位置。
3.操作系统内核设计与实现–操作系统内核是整个操作系统的核心部分，它负责管理系统的资源和提供系统调度等功能。
–在本次实验中，我们可以设计和实现一个简单的操作系统内核，包括进程管理、内存管理、文件系统等功能。
4.系统调用设计与实现–系统调用是用户程序与操作系统之间的接口，用户程序通过系统调用请求操作系统提供的服务。
–在本次实验中，我们可以设计和实现一些基本的系统调用，如文件读写、进程创建等。
5.调试与测试–在进行操作系统开发的过程中，调试和测试是非常重要的环节。
–在本次实验中，我们可以使用Bochs模拟器来模拟运行我们编写的操作系统内核，并对其进行调试和测试。
实验结果与分析经过一段时间的编写和调试，我们成功地完成了一个简单的操作系统内核的设计和实现。
在实验过程中，我们深入理解了操作系统的工作原理和基本功能，提高了对操作系统相关知识的理解和应用能力。
同时，我们还进一步锻炼了编程和调试的实践能力。
东北大学操作系统实验之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。
操作系统实验报告一
操作系统实验报告一操作系统实验报告一引言：操作系统是计算机系统中最核心的软件之一，它负责管理和协调计算机硬件和软件资源的分配和调度，为用户提供一个友好、高效、安全的计算环境。
本实验报告旨在总结和分析我在操作系统实验一中所学到的知识和经验，包括实验目的、实验环境、实验过程和实验结果等方面。
一、实验目的操作系统实验一的主要目的是熟悉和掌握操作系统的基本概念和基本操作。
通过实际操作，了解操作系统的启动过程、命令行界面的使用、文件和目录管理、进程管理等内容，为后续的实验和学习打下基础。
二、实验环境本次实验使用的操作系统是Linux，具体是Ubuntu 20.04 LTS版本。
实验所需的软件包括VirtualBox虚拟机软件和Ubuntu镜像文件。
三、实验过程1. 虚拟机环境搭建首先，需要安装VirtualBox虚拟机软件，并导入Ubuntu镜像文件。
通过设置虚拟机的内存大小、硬盘空间等参数，创建一个适合的虚拟机环境。
2. 操作系统启动启动虚拟机后，选择Ubuntu系统进行启动。
在启动过程中，可以观察到操作系统加载各种驱动程序和初始化系统资源的过程。
3. 命令行界面的使用Ubuntu系统默认使用命令行界面，需要掌握基本的命令行操作。
比如，使用cd命令切换目录，使用ls命令查看目录内容，使用mkdir命令创建新目录等。
4. 文件和目录管理在命令行界面下，可以使用各种命令进行文件和目录的管理。
比如，使用touch命令创建新文件，使用cp命令复制文件，使用rm命令删除文件等。
5. 进程管理操作系统需要管理和调度各个进程的执行。
在实验中，可以使用ps命令查看当前运行的进程，使用kill命令终止指定的进程。
四、实验结果通过实验，我成功地搭建了虚拟机环境，并启动了Ubuntu操作系统。
在命令行界面下，我熟练地使用了各种命令进行文件和目录的管理，也了解了进程的基本管理方法。
实验结果表明，我对操作系统的基本概念和基本操作有了初步的了解和掌握。
东北大学操作系统实验报告
课程编号：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）什么是进程的同步？什么是进程的互斥？分别有哪些实现方式？答：进程互斥是进程之间的间接制约关系。
东北大学操作系统实验三报告
操作系统实验报告班级物联网1302班学号姓名实验3 进程同步和通信-生产者和消费者问题模拟1. 目的：调试、修改、运行模拟程序，通过形象化的状态显示，使学生理解进程的概念，了解同步和通信的过程，掌握进程通信和同步的机制，特别是利用缓冲区进行同步和通信的过程。
通过补充新功能，使学生能灵活运用相关知识，培养创新能力。
2. 内容及要求：1) 调试、运行模拟程序。
2) 发现并修改程序中不完善的地方。
3) 修改程序，使用随机数控制创建生产者和消费者的过程。
4) 在原来程序的基础上，加入缓冲区的写互斥控制功能，模拟多个进程存取一个公共缓冲区，当有进程正在写缓冲区时，其他要访问该缓冲区的进程必须等待，当有进程正在读取缓冲区时，其他要求读取的进程可以访问，而要求写的进程应该等待。
5) 完成1)、2)、3）功能的,得基本分,完成4)功能的加2分,有其它功能改进的再加2分3. 程序说明：本程序是模拟两个进程，生产者（producer）和消费者(Consumer)工作。
生产者每次产生一个数据，送入缓冲区中。
消费者每次从缓冲区中取走一个数据。
缓冲区可以容纳8个数据。
因为缓冲区是有限的，因此当其满了时生产者进程应该等待，而空时，消费者进程应该等待；当生产者向缓冲区放入了一个数据，应唤醒正在等待的消费者进程，同样，当消费者取走一个数据后，应唤醒正在等待的生产者进程。
就是生产者和消费者之间的同步。
每次写入和读出数据时，都将读和写指针加一。
当读写指针同样时，又一起退回起点。
当写指针指向最后时，生产者就等待。
当读指针为零时，再次要读取的消费者也应该等待。
为简单起见，每次产生的数据为0-99的整数，从0开始，顺序递增。
两个进程的调度是通过运行者使用键盘来实现的。
4. 程序使用的数据结构进程控制块：包括进程名，进程状态和执行次数。
缓冲区：一个整数数组。
缓冲区说明块：包括类型，读指针，写指针，读等待指针和写等待指针。
5. 程序使用说明启动程序后，如果使用'p'键则运行一次生产者进程，使用'c'键则运行一次消费者进程。
[操作系统实验报告范文(1)]操作系统实验报告范文2
![[操作系统实验报告范文(1)]操作系统实验报告范文2](https://img.taocdn.com/s3/m/f913fa1d2379168884868762caaedd3383c4b59e.png)
[操作系统实验报告范文(1)•]操作系统实验报告范文2学号：姓名：班级：成绩:实验名称：Linu某常用命令实验实验地点：所使用的工具软件及环境：Linu某、实验目的:本实验的目的是熟悉Linu某操作系统的命令接口、图形接口和程序接口；了解Linu某操作系统的启动过程;了解Linu某操作系统的目录结构；用vi编辑器编写简单的C语言程序，并用gcc编译器编译、运行。
二、实验内容：按题目要求完成观察操作系统的行为和程序的编写。
1、实现开机、登录、退出与关机：⑴如果以root用户登录，那么命令窗口的提示符为#;如果以普通用户登录，那么命令窗口的提示符为$;登录用户名：uer口令：123456修改口令(不做)：成功进入系统后，在命令提示符后输入pawd'并键入回车键退出账号：命令方式下：logout关机或重启：命令方式下：hutdown、halt、reboot窗口方式下：主菜单->关闭系统”-〉关机或重启”->……2、掌握的根本常用命令列表关于目录的操作命令：cd、l$mkdir、rmdir、pwd等；关于文件的操作命令：cat、find、vi/vim、cp、rm、mv、dd、du、df、chmod、ln等；关于进程管理的操作命令：p、kill、top、free等；关于系统管理的操作命令：whoami、pawd、adduer、addgroup、uerdel>groupdel>u、who、Ctrl+Alt+Fn(n=1、2、3、4、5、6)等；安装和卸载文件系统：mount、umount等；显示有关计算机系统信息的命令：uname(显示操作系统的名称)、uname~n(显示系统域名)、uname■p(显示系统的CPU名称)使用man命令来获得每个Linu某命令的帮助手册，用manl,manpawd,manpwd命令得至Vl、pawd、pwd三个命令的帮助手册。
也可以使用：命令名--help格式来显示该命令的帮助信息，如who-help3、阅读/etc/inittab文本文件，思考问题：如果要求启动Linu某系统之后进入字符界面，应如何修改/etc/inittab文件？用户应具有什么权限？4、切换到不同的虚拟终端登录到Linu某系统。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统的核心组成部分，本次实验的主要目的是深入理解操作系统的工作原理和功能，通过实际操作和观察，掌握操作系统的进程管理、内存管理、文件系统管理等方面的知识和技能。
二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。
三、实验内容及步骤1、进程管理实验（1）创建进程通过编程实现创建新的进程。
在代码中使用了 Windows API 函数CreateProcess 来创建一个新的进程。
首先，设置进程的启动信息，包括命令行参数、工作目录等。
然后，调用CreateProcess 函数创建进程，并检查返回值以确定创建是否成功。
（2）进程同步使用互斥量（Mutex）实现进程间的同步。
创建一个共享资源，多个进程尝试访问该资源。
通过互斥量来保证同一时间只有一个进程能够访问共享资源，避免了数据竞争和不一致的问题。
（3）进程通信采用管道（Pipe）进行进程间的通信。
创建一个匿名管道，一个进程作为发送端，向管道写入数据；另一个进程作为接收端，从管道读取数据。
通过这种方式实现了进程之间的数据交换。
2、内存管理实验（1）内存分配使用 Windows API 函数 VirtualAlloc 来分配内存。
指定分配的内存大小、访问权限等参数，并检查返回的内存指针是否有效。
（2）内存释放在不再需要使用分配的内存时，使用 VirtualFree 函数释放内存，以避免内存泄漏。
（3）内存保护设置内存的保护属性，如只读、读写等，以防止非法访问和修改。
3、文件系统管理实验（1）文件创建与写入使用 CreateFile 函数创建一个新文件，并通过 WriteFile 函数向文件中写入数据。
（2）文件读取使用 ReadFile 函数从文件中读取数据，并将读取的数据输出到控制台。
（3）文件属性操作获取文件的属性信息，如文件大小、创建时间、修改时间等，并进行相应的操作和显示。
东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 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 命中： " ;
操作系统实验报告1
实验一：搭建实验环境一、实验目的1．熟悉Ubuntu 实验环境以及Oslab 工作平台；2．熟悉x86 模拟器Bochs、GCC 编译器、DB 调试器；3．初步接触Linux 0.11 操作系统。
二、实验仪器Ubuntu 操作系统。
三、实验步骤本操作系统实验的硬件环境是IA-32(x86)架构的PC 机，主要软件环境是Bochs + gcc + 编辑器/IDE + 操作系统+ Linux 0.11源代码。
实验的基本流程是根据实验要求编写应用程序、修改Linux 0.11 的源代码，用gcc 编译后，在Bochs 的虚拟环境中运行、调试目标代码。
四、实验步骤1．搭建Oslab 工作平台：在用户主目录下启动命令行终端，输入：tar zxvf hit-oslab-linux-20110823.tar.gz安装Oslab；2．准备活动：输入：cd ~/oslab切换目录，用：ls -l列出目录内容；3．编译内核：切换至"/home/shiyanlou/oslab/linux-0.11"目录，然后执行：make all编译内核，结果如图1 所示；4．启动Bochs：切换至"/home/shiyanlou/oslab"目录，然后执行：./run启动Bochs，结果如图 2 所示；5．熟悉Ubuntu 和Linux 0.11 之间的文件交换：切换至"/home/shiyanlou/oslab"目录，然后执行：sudo ./mount-hdc之后切换至"/home/shiyanlou/oslab/hdc"目录，然后执行：ls –l五、实验截图实验二：控制系统启动过程一、实验目的1．熟悉hit-oslab 工作平台；2．建立对操作系统引导过程的深入认识；3．掌握操作系统的基本开发过程4．初步接触Linux 0.11 操作系统。
二、实验仪器Ubuntu 操作系统。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验1Linux系统的基本操作和开发环境
一、目的：
熟悉和掌握Linux基本命令，熟悉Linux编程环境，为以后的实验做好准备。
二、内容及要求：
1）熟练掌握Linux基本文件命令。
2）掌握Linux编辑程序、对源代码进行编译、连接、运行及调试的过程。
3）认真做好预习，书写预习报告。
4）实验完成后要认真总结、完成实验报告。
三、实验中Linux的命令及其含义
1. 创建子目录命令 mkdir
用法: mkdir subdir ( 例: $ mkdir aaa)
2. 转换路径命令 cd
用法: cd subdir (例: cd aaa, cd / , cd ..) 3. 显示当前工作路径命令 pwd
用法: pwd
4. 拷贝文件命令 cp
用法: cp sfile dfile
5. 删除文件命令 rm
用法: rm filename
6. 删除子目录命令 rmdir
用法: rmdir dfileame (空目录)
7. 显示文件内容和file1 与 file2之间的连接 cat
(1) cat filename
(2) cat file1 file2 > file3
8. 改变文件或目录的访问权限 chmod
-rwxr-x—x filename ( 其中:r----4 w----2 x----1 )
drwxr-x--x
用法:chmod + - = rwx 文件名
$chmod +644 aa.c -rw-r—r--
9. 改变文件或目录的拥有者 chown
用法: chown 文件名用户名
10. 列表显示文件名或目录名 ls
用法: ls 或 ls -l
11. 查找文件或目录 find
用法: find 文件名或目录名
12. 显示进程或状态 ps
用法: ps 或 ps -al
四、在Linux环境下编制、调试源程序的实际过程（每一步的具体说
明）
编译: (1) $gcc -o 目标文件名.out 源文件名.c (2) $ g++ -o 目标文件名.out 源文件名.cpp 运行: $ ./目标文件名.out
如下图：。