上海大学操作系统(二)实验报告(全)
操作系统实验报告(全)
操作系统实验报告书院系名称：电子工程学院电子指导教师：班级：学号：学生姓名：实验题目一：进程一、实验目的通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSIX 规范中fork和kill系统调用的功能和使用。
二、实验内容（1）补充POSIX 下进程控制的残缺版实验程序（2）回答下列问题：1. 你最初认为运行结果会怎么样？2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。
3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？5. 使用kill 命令可以在进程的外部杀死进程。
进程怎样能主动退出？这两种退出方式哪种更好一些？三、实验步骤1.根据题意进入DOC环境中编写程序。
2.编译，链接，运行程序，进行调试。
3.分析实验结果及回答问题。
四、调试情况，回答问题及体会1、对自己设计进行评价，指出合理和不足之处，提出改进的方案。
2、在设计过程中的感受。
调试情况：回答上述实验内容中的问题1．预期结果：会持续输出0-9号进程，直到输入数字键+回车，则会杀死该进程，接下来的输出将不会有该进程号，当输入q+回车，则退出程序。
2．实际结果：与预期差不多，因输入进程总数20大于设定的最大进程数，因此按进程数10来处理。
随机输出0-9号进程，sleep(SLEEP_INTERV AL)，循环输出，直到输入数字键，则会杀死该数字对应的进程，直到输入q退出循环，然后杀死本组所有进程。
分析：每创建一个子进程时，将其pid存储在pid[i]中，i存储在proc_number，然后调用死循环函数do_something()，输出该进程的代号proc_number；当输入数字键时，主进程会执行kill(pid[ch-'0'],SIGTERM)，从而杀死（ch-‘0’）号进程。
上海大学操作系统(二)实验报告(全)
评分：SHANGHAI UNIVERSITY操作系统实验报告学院计算机工程与科学专业计算机科学与技术学号学生姓名《计算机操作系统》实验一报告实验一题目：操作系统的进程调度姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： Microsoft Visual Studio实验目的：进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。
本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。
调度算法可任意选择或自行设计。
例如，简单轮转法和优先数法等。
本实习可加深对于进程调度和各种调度算法的理解。
实验内容：1、设计一个有n个进程工行的进程调度程序。
每个进程由一个进程控制块（PCB）表示。
进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。
2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。
3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。
操作过程：1、本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。
为了便于处理，程序进程的运行时间以时间片为单位计算。
进程控制块结构如下：进程控制块结构如下：PCB进程标识数链指针优先数/轮转时间片数占用 CPU 时间片数进程所需时间片数进程状态进程控制块链结构如下：其中：RUN—当前运行进程指针；HEAD—进程就绪链链首指针；TAID—进程就绪链链尾指针。
2、算法与框图(1) 优先数法。
进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。
实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。
三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。
在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。
通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。
2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。
通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。
在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。
（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。
通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。
2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。
在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。
（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。
操作系统实验二实验报告
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术，包括进程的创建、执行、同步和通信。
通过实际编程和实验操作，提高对操作系统原理的认识，培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。
2、在项目中，使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束，并获取其退出代码。
（二）进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区，当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理，当缓冲区为空时等待。
（三）进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道，父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据，子进程从管道读取数据并进行处理。
四、实验结果及分析（一）进程创建实验结果成功创建了新的进程，并能够获取到其退出代码。
通过观察进程的创建和执行过程，加深了对进程概念的理解。
（二）进程同步实验结果通过使用信号量，生产者和消费者进程能够正确地进行同步，避免了缓冲区的溢出和数据的丢失。
分析结果表明，信号量机制有效地解决了进程之间的资源竞争和协调问题。
（三）进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递，验证了管道通信的有效性。
五、遇到的问题及解决方法（一）在进程创建实验中，遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试，最终正确设置了参数，成功创建了进程。
（二）在进程同步实验中，出现了信号量使用不当导致死锁的情况。
操作系统lab2实验报告
操作系统lab2实验报告实验目的：本实验的目的是通过设计和实现一个简单的操作系统内核，加深对操作系统基本概念和原理的理解。
具体实验内容包括进程管理、内存管理和文件系统的设计与实现。
实验环境：1.操作系统：Linux2.编程语言：C语言一、实验背景1.1 操作系统简介操作系统是计算机系统中的一个重要组成部分，负责管理和控制计算机的各种资源，提供用户和应用程序的接口，以及协调和调度各种任务的执行。
1.2 实验目标本实验的主要目标是设计和实现一个简单的操作系统内核，包括进程管理、内存管理和文件系统等功能。
二、实验内容2.1 进程管理①进程创建描述进程创建的过程和相关数据结构，包括创建新进程的系统调用、进程控制块等。
②进程调度描述进程调度的算法和实现方式，包括进程调度队列、调度算法等。
③进程同步与通信描述进程同步和通信的机制和方法，包括信号量、互斥锁、条件变量等。
2.2 内存管理①内存分配描述内存分配的算法和实现方式，包括连续内存分配、非连续内存分配等。
②页面置换描述页面置换的算法和实现方式，包括最优页面置换算法、先进先出页面置换算法等。
2.3 文件系统①文件操作描述文件操作的系统调用和相关数据结构，包括文件打开、读写、关闭等。
②文件系统结构描述文件系统的组织结构和实现方式，包括超级块、索引节点、块位图等。
三、实验步骤3.1 环境搭建搭建实验环境，包括安装Linux操作系统、编译器等。
3.2 进程管理实现根据设计要求，实现进程创建、调度、同步与通信等功能。
3.3 内存管理实现根据设计要求，实现内存分配、页面置换等功能。
3.4 文件系统实现根据设计要求，实现文件操作和文件系统结构。
3.5 测试与调试编写测试用例，对实现的操作系统内核进行测试和调试，并记录实验结果。
四、实验结果分析分析测试结果，评估实验过程中遇到的问题和解决方法，总结操作系统内核的性能和功能特点。
五、实验总结对实验过程中的收获和经验进行总结，提出改进和优化的建议。
操作系统实习二报告
实验二主存储器空间的分配和回收一、实验题目：模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。
二、实验目的：主存的分配和回收的实现与主存储器的管理方式有关，通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验内容：一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
四、程序中使用的数据结构及符号说明：五、程序流程图：六、程序源代码：#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n)/*尾插法创建带头结点的单链表*/{linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("\n请分别输入页表的页号及块号（-1表示空）：\n");printf("\n页号| 块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void init(int g[100][100],int N)/*初始化位示图，将值全置为零，0表示空闲状态*/{int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0; //全置为零}}g[N+1][0]=N*N; //在数组最后一个数的后面设置一个空间用来存放剩余空闲块数}linklist Init(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=1;g[N+1][0]--;p=p->next;}}return head;}printStr(int g[100][100],int N)/*打印位示图*/{int i,j;printf("\n此时位示图为：\n");printf("\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}printf("\n");}void print(linklist head)/*输出带头结点的单链表*/{linklist p;p=head->next;printf("\n该页表为:\n");printf("\n");printf("\n 页号| 块号\n");while(p){printf("%11d%7d\n",p->pageNum,p->blockNum);p=p->next;}printf("\n");}linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j; //将对应块号记录到页表g[i][j]=1; //将块置1，表示已被占用g[N+1][0]--; //剩余空闲块减1break; //跳出循环，进行下一个页的分配}}break; //跳出循环}p=p->next; //下一个页进行分配}return head;}}linklist Recy(linklist head,int g[100][100],int n,int N)/*回收已经完成的页*/ {int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n) //找出要回收的页号{p=p->next;}if(p) //找到{i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0; //将该块置0，表空闲状态g[N+1][0]++;p->blockNum=-1; //页表中对应的块号为空，置成-1}return head;}void main(){int m,n,N;int x,y,a,b,t;int graph[100][100];linklist head,Head;printf("\n*****分页式存储管理分配及回收算法*****\n");printf("\n请输入位示图字长：");scanf("%d",&N);printf("\n请输入已占用内存作业的页数：");scanf("%d",&m);head=creatlinklist(m);init(graph,N);head=Init(head,graph,m,N);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n现在进行作业分配：\n");printf("\n请输入需要分配的作业的页数：");scanf("%d",&n);Head=creatlinklist(n);Head=Dis(Head,graph,n,N);print(Head);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n您是否想回收已完成的页，“是”请按1，“否”请按0：");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号：");scanf("%d %d %d %d",&y,&a,&b,&t);head=Recy(head,graph,y,N);head=Recy(head,graph,a,N);head=Recy(head,graph,b,N);head=Recy(head,graph,t,N);printStr(graph,N);}printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n");}七、运行结果：实习小结：本次实验是自己花了很多的时间去琢磨去尝试才完成的，虽然还不是很完美，但是在设计的过程中自己在对编程方面的逻辑思维得到了很好的锻炼。
《操作系统》课内实验报告
《操作系统》课内实验报告一、实验目的本次《操作系统》课内实验的主要目的是通过实际操作和观察，深入理解操作系统的基本原理和功能，掌握常见操作系统命令的使用，提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在计算机实验室进行，使用的操作系统为 Windows 10 和Linux（Ubuntu 发行版）。
实验所使用的计算机配置为：Intel Core i5 处理器，8GB 内存，500GB 硬盘。
三、实验内容1、进程管理在 Windows 系统中，通过任务管理器观察进程的状态、优先级、CPU 使用率等信息，并进行进程的结束和优先级调整操作。
在 Linux 系统中，使用命令行工具（如 ps、kill 等）实现相同的功能。
2、内存管理使用 Windows 系统的性能监视器和资源监视器，查看内存的使用情况，包括物理内存、虚拟内存的占用和分配情况。
在 Linux 系统中，通过命令（如 free、vmstat 等）获取类似的内存信息，并分析内存的使用效率。
3、文件系统管理在 Windows 系统中，对文件和文件夹进行创建、复制、移动、删除等操作，了解文件的属性设置和权限管理。
在 Linux 系统中，使用命令（如 mkdir、cp、mv、rm 等）完成相同的任务，并熟悉文件的所有者、所属组和权限设置。
4、设备管理在 Windows 系统中，查看设备管理器中的硬件设备信息，安装和卸载设备驱动程序。
在 Linux 系统中，使用命令（如 lspci、lsusb 等）查看硬件设备，并通过安装内核模块来支持特定设备。
四、实验步骤1、进程管理实验（1）打开 Windows 系统的任务管理器，切换到“进程”选项卡，可以看到当前系统中正在运行的进程列表。
（2）选择一个进程，右键点击可以查看其属性，包括进程 ID、CPU 使用率、内存使用情况等。
（3）通过“结束任务”按钮可以结束指定的进程，但要注意不要随意结束系统关键进程，以免导致系统不稳定。
操作系统2实验4报告
实验(四)文件操作与管理一、目的与要求1、目的随着社会信息量的极大增长，要求计算机处理的信息与日俱增，涉及到社会生活的各个方面。
因此，文件管理是操作系统的一个极为重要的组成部分。
学生应独立地用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深理解课堂上讲授过的知识。
2、要求（1）实际一个 n 个用户的文件系统，每个用户最多可保存 m 个文件。
（2）限制用户在一次运行中只能打开 l 个文件。
（3）系统应能检查打入命令的正确性，出错要能显示出错原因。
（4）对文件必须设置保护措施，如只能执行，允许读、允许写等。
在每次打开文件时，根据本次打开的要求，再次设置保护级别，即可有二级保护。
（5）对文件的操作至少应有下述几条命令：creat 建立文件。
delete 删除文件。
open 打开文件。
close 关闭文件。
read 读文件。
write 写文件。
二、实验题目（1）本实习设计一个 10 个用户的文件系统，每个用户最多可保存 10 个文件，一次运行中用户可打开 5 个文件。
（2）程序采用二级文件目录，即设置了主文件目录（MFD）和用户文件目录（UFD）。
前者应包含文件主（即用户）及他们的目录区指针；后者应给出每个文件主占有的文件目录，即文件名，保护码，文件长度以及他们存放的位置等。
另外为打开文件设置了运行文件目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。
（3）为了便于实现，对文件的读写作了简化，在执行读写命令时，只修改读写指针，并不进行实际文件的读写操作。
三、实验源代码#include <cstdio>#include <cstring>#define SizeOfUserName 255#define SizeOfUser 10#define SizeOfFile 10#define SizeOfCommand 255#define SizeOfFileName 255char UserName[SizeOfUser][SizeOfUserName];long User;struct InfoOfFile {char Name[SizeOfFileName];bool safe[3];//Read,Write,Executelong status;//ready,open;}UFD[SizeOfUser][SizeOfFile];long num[SizeOfUser];long num_open[SizeOfUser];char z[4]="rwe";void ls()//列文件目录{char tmp[100];long i,j;printf("%20s%20s%20s\n","Name","Property","Status");for (i=0;i<num[User];i++){printf("%20s",UFD[User][i].Name);for (j=0;j<3;j++){if (UFD[User][i].safe[j]){tmp[j]=z[j];}else{tmp[j]='-';}}tmp[3]='\0';printf("%20s",tmp);if (UFD[User][i].status){printf("%20s\n","Opened");}else{printf("%20s\n","Ready");}}printf("%ld file(s) in total\n",num[User]);}long login()//切换用户{long i;char NameInput[SizeOfUserName];do{printf("Please input your ID:");scanf("%s",NameInput);i=0;while (i<SizeOfUser && strcmp(NameInput,UserName[i])!=0){i++;}if (strcmp(NameInput,UserName[i])!=0){printf("Bad UserID.\n");}}while (strcmp(NameInput,UserName[i])!=0);return i;}void init()//初始化{long i,j,k;char tmp[4];memset(num_open,0,sizeof(num_open));//读入用户名列表freopen("record.txt","r",stdin);for (i=0;i<SizeOfUser;i++){scanf("%s",UserName[i]);}//读入文件列表for (i=0;i<SizeOfUser;i++){scanf("%ld",&num[i]);for (j=0;j<num[i];j++){scanf("%s%s",UFD[i][j].Name,tmp);for (k=0;k<3;k++){if (tmp[k]=='-'){UFD[i][j].safe[k]=0;}else{UFD[i][j].safe[k]=1;}}UFD[i][j].status=0;}}freopen("con","r",stdin);User=login();ls();}void create()//创建文件{long i;char filename[SizeOfFileName];char prop[128];if (num[User]==SizeOfFile)//保存已满{printf("Failed... You can only save %ld files\n",SizeOfFile);return;}printf("Input filename and property>");scanf("%s%s",filename,prop);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0)//重名{printf("Failed... File %s already exists\n",filename);return;}}strcpy(UFD[User][num[User]].Name,filename);for (i=0;i<3;i++)//设置属性{if (prop[i]=='-'){UFD[User][num[User]].safe[i]=0;}else{UFD[User][num[User]].safe[i]=1;}}UFD[User][num[User]].status=0;++num[User];printf("Success!\n");}void open()//打开文件{long i;char filename[SizeOfFileName];if (num_open[User]==5){printf("Failed... You have already opened 5 files\n");//打开文件数已到上限return ;}printf("Input filename>");scanf("%s",filename);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0){if (UFD[User][i].status==0)//文件未占用{UFD[User][i].status=1;num_open[User]++;printf("Success!\n");}else//已被打开{printf("Failed... File %s is already opened\n",filename);}return;}}printf("Failed... No such file\n"); //找不到文件}void close()//关闭文件{long i;char filename[SizeOfFileName];printf("Input filename>");scanf("%s",filename);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0){if (UFD[User][i].status==1)//成功{UFD[User][i].status=0;num_open[User]--;printf("Success!\n");}else//文件并未打开{printf("Failed... File %s is not opened\n",filename);}return;}}printf("Failed... No such file\n"); //找不到文件}void read()//读文件{long i;char filename[SizeOfFileName];printf("Input filename>");scanf("%s",filename);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0){if (UFD[User][i].safe[0]==0)//属性设置为不可读{printf("Failed... File %s is not readable\n",filename);return;}if (UFD[User][i].status==1)//文件已打开{printf("Failed... File %s is already opened\n",filename);return;}printf("Success!\n");//成功return;}}printf("Failed... No such file\n");//找不到文件}void write()//写文件{long i;char filename[SizeOfFileName];printf("Input filename>");scanf("%s",filename);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0){if (UFD[User][i].safe[1]==0)//属性设置为不可写{printf("Failed... File %s is not writable\n",filename);return;}if (UFD[User][i].status==1)//已打开{printf("Failed... File %s is already opened\n",filename);return;}printf("Success!\n");//成功return;}}printf("Failed... No such file\n");//找不到文件}void mydelete()//删除文件{long i,j;char filename[SizeOfFileName];printf("Input filename>");scanf("%s",filename);for (i=0;i<num[User];i++){if (strcmp(filename,UFD[User][i].Name)==0){if (UFD[User][i].status==1)//文件正被打开{printf("Failed... File %s is already opened\n",filename);return;}num[User]--;for (j=i;j<num[User];j++){UFD[User][j]=UFD[User][j+1];}printf("Success!\n");//成功return;}}printf("Failed... No such file\n");//找不到文件}void save()//保存本次信息{FILE *fp=fopen("record.txt","w");long i,j,k;char tt[4]="rwe";char tmp[4];//保存用户列表for (i=0;i<SizeOfUser;i++){fprintf(fp,"%s\n",UserName[i]);}//保存文件列表for (i=0;i<SizeOfUser;i++){fprintf(fp,"%ld\n",num[i]);for (j=0;j<num[i];j++){for (k=0;k<3;k++){if (UFD[i][j].safe[k]){tmp[k]=tt[k];}else{tmp[k]='-';}}tmp[3]=0;fprintf(fp,"%s %s\n",UFD[i][j].Name,tmp);}}printf("Success!\n");//成功fclose(fp);}void work()//交互主函数{bool over=0;char command[SizeOfCommand];while (!over){printf("%s>",UserName[User]);scanf("%s",command);if (strcmp(command,"login")==0){User=login();ls();continue;}if (strcmp(command,"bye")==0){printf("Byebye.\n");over=1;continue;}if (strcmp(command,"ls")==0 || strcmp(command,"dir")==0){ls();continue;}if (strcmp(command,"create")==0){create();continue;}if (strcmp(command,"delete")==0){mydelete();continue;}if (strcmp(command,"open")==0){open();continue;}if (strcmp(command,"close")==0){close();continue;}if (strcmp(command,"read")==0){read();continue;}if (strcmp(command,"write")==0){write();continue;}if (strcmp(command,"save")==0){save();continue;}printf("Bad command.\n");}}int main(){init();work();return 0;}。
操作系统(二)实验报告_上海大学计算机与科学系
操作系统（二）实验报告姓名：米博计算机工程与科学学院实验四 Linux文件系统实验一. 实验目的掌握操作系统中文件分类的概念。
了解Linux文件系统管理文件的基本方式和特点。
学会使用Linux文件系统的命令界面和程序界面的基本要领。
二.实验准备复习操作系统中有关文件系统的知识，熟悉文件的类型、i节点、文件属性、文件系统操作等概念。
熟悉《实验指导》第五部分“文件系统的系统调用”。
了解Linux文件系统的特点、分类。
阅读例程中给出的相应的程序段。
三.实验方法运行命令界面的各命令并观察结果。
用vi编写c程序（假定程序文件名为prog1.c）编译程序$gcc –o prog1.o prog1.c或$cc –o prog1.o prog1.c运行$./prog1.o观察运行结果并讨论。
四.实验内容及步骤1. 用shell命令查看Linux文件类型。
思考：Linux文件类型有哪些？用什么符号表示。
答：文件类型：没有后缀的文件、可执行文件、可读写的文本文件。
.conf —某个程序的配置文件.c — C语言程序源码文件.so —动态链接库文件.tcl — TCL脚本文件.cpp — C++语言程序源码文件.h — C或C++语言的头文件.o —程序对象文件.pl — Perl脚本文件.sh —shell批处理文件2. 用shell命令了解Linux文件系统的目录结构。
执行$ cd /lib$ ls -l|more看看/lib目录的内容，显示的函数都是系统函数。
再看看/etc，这里都是系统设置用的配置文件：/bin中是可执行程序；/home下包括了每个用户主目录。
3. 用命令分别建立硬链接文件和符号链接文件。
通过ls –il命令所示的inode、链接计数观察它们的区别。
找找一个其他目录中的文件，如：/home/zzl/mytese.c执行$ ln /home/zzl/mytest.c myt.c （建立硬链接文件）$ ln –s /home/zzl/mytest.c myt2.c （建立符号链接文件）思考：建立硬链接文件和建立符号链接文件有什么区别，体现在哪里？答：硬链接文件就是给文件取另外一个名字，链接使用inode是与元文件相同的。
操作系统实验报告实验二
操作系统实验报告实验二一、实验目的本次操作系统实验二的目的在于深入理解和掌握操作系统中的进程管理和进程调度相关知识，通过实际的编程和实验操作，观察和分析不同进程调度算法的性能和效果，提高对操作系统核心概念的理解和应用能力。
二、实验环境本次实验在 Windows 10 操作系统下进行，使用 Visual Studio 2019作为编程工具。
实验中涉及的编程语言为 C+＋。
三、实验内容（一）进程创建与控制编写程序实现创建多个进程，并通过进程控制原语（如创建、等待、终止等）对进程进行管理和控制。
（二）进程调度算法实现1、先来先服务（FCFS）调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源进行执行。
2、短作业优先（SJF）调度算法优先调度执行时间短的进程，以减少平均等待时间。
3、时间片轮转（RR）调度算法将 CPU 时间划分为固定大小的时间片，每个进程在一个时间片内执行，时间片结束后切换到下一个进程。
（三）性能评估指标1、平均等待时间所有进程等待时间的总和除以进程数量。
2、平均周转时间所有进程周转时间的总和除以进程数量。
周转时间为进程从提交到完成的时间间隔。
四、实验步骤（一）进程创建与控制1、定义进程结构体，包含进程 ID、到达时间、执行时间等信息。
2、使用系统调用或库函数创建进程。
3、在父进程中通过等待函数等待子进程结束，并获取子进程的返回状态。
（二）进程调度算法实现1、先来先服务（FCFS）调度算法按照进程到达时间的先后顺序将进程放入就绪队列。
从就绪队列中取出第一个进程进行调度执行。
2、短作业优先（SJF）调度算法计算每个进程的执行时间。
按照执行时间从小到大的顺序将进程放入就绪队列。
从就绪队列中取出执行时间最短的进程进行调度执行。
3、时间片轮转（RR）调度算法将进程按照到达时间先后顺序放入就绪队列。
为每个进程分配一个时间片，当时间片用完后，将进程放入就绪队列尾部，重新调度下一个进程。
操作系统Lab2实验报告
深入学习 操作系统的原理和实 现细节，包括进程通 信、死锁处理、虚拟 化技术等。
实践应用
希望将所学的操作系 统知识应用到实际项 目中，提高自己的实 践能力。
持续学习
随着技术的不断发展 ，操作系统也在不断 更新和进步，需要保 持持续学习的态度。
探索新领域
对于新兴的操作系统 领域，如云操作系统 、物联网操作系统等 ，也希望有所涉猎和 探索。
学生将了解操作系统内核的组成和功能，以及操作系统如何通过内核 实现各种基本功能。
学生将通过实验深入了解操作系统的内部实现细节，提高自己对操作 系统设计和实现的认知水平。
02
实验内容
进程管理实验
总结词
理解进程状态及其转换、进程控制块PCB的组成、进程调度算法。
详细描述
通过实验，我们深入了解了进程的概念、状态及其转换。进程控制块PCB的组成，包括进程标 识符、进程状态、优先级、CPU寄存器内容等信息。此外，我们还学习了进程调度算法，如先 来先服务、最短作业优先、优先级调度等，并进行了模拟实验。
THANKS
感谢观看
操作系统Lab2实验 报告
汇报人：
202X-01-08
目录
• 实验目的 • 实验内容 • 实验结果与分析 • 问题与改进建议 • 总结与展望
01
实验目的
理解操作系统的基本概念
01
掌握核心概念
02
操作系统是计算机系统的核心软件，负责管理计算机硬件和软件资源 ，为用户提供便利的操作界面和高效的服务。
03
操作系统具有并发性、虚拟性、异步性和随机性的特点，这些特点决 定了操作系统在计算机系统中的重要地位和作用。
04
操作系统的基本功能包括进程管理、内存管理、文件管理和设备管理 ，这些功能是操作系统实现其核心目标的基础。
计算机操作系统试验上海大学
SHANGHAI UNIVERSITY计算机操作系统实验报告（实验三、六）学院计算机工程与科学学院专业计算机科学与技术组号第28 组姓名11121763 盛俊教师沈俊赵正德日期2013-10-25实验三进程管理及进程通信一. 实验目的利用Linux提供的系统调用设计程序，加深对进程概念的理解。
体会系统进程调度的方法和效果。
了解进程之间的通信方式以及各种通信方式的使用。
二. 实验准备复习操作系统课程中有关进程、进程控制的概念以及进程通信等内容（包括软中断通信、管道、消息队列、共享内存通信及信号量概念）。
熟悉本《实验指导》第五部分有关进程控制、进程通信的系统调用。
它会引导你学会怎样掌握进程控制。
阅读例程中的程序段。
三. 实验方法用vi 编写c 程序（假定程序文件名为prog1.c）编译程序$ gcc -o prog1.o prog1.c 或$ cc -o prog1.o prog1.c 运行$./prog1.o四. 实验内容及步骤1. 编写程序。
显示进程的有关标识（进程标识、组标识、用户标识等）。
经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。
2. 参考例程1，编写程序。
实现父进程创建一个子进程。
体会子进程与父进程分别获得不同返回值，进而执行不同的程序段的方法。
思考：子进程是如何产生的？又是如何结束的？子进程被创建后它的运行环境是怎样建立的？答:是由父进程用fork()函数创建形成的，通过exit()函数自我结束，子进程被创建后核心将其分配一个进程表项和进程标识符，检查同时运行的进程数目，并且拷贝进程表项的数据，由子进程继承父进程所有文件。
3. 参考例程2，编写程序。
父进程通过循环语句创建若干子进程。
探讨进程的家族树以及子进程继承父进程的资源的关系。
思考题：①画出进程的家族树。
子进程的运行环境是怎样建立的？反复运行此程序看会有什么情况？解释一下。
②修改程序，使运行结果呈单分支结构，即每个父进程只产生一个子进程。
操作系统第二次实验报告
semctl(semid,2,IPC_RMID,0);
semctl(semid,3,IPC_RMID,0);
gettimeofday(&_end,NULL);
exe_time = ((float)(__sec - __sec)*1000000+(float)(__usec - __usec))/1000000;
2)利用Linux操作系统提供的信号量工具实现进程间的同步；
3)掌握对共享内存的相关操作；
4)基于生产者-消费者同步的原理实现双缓冲区的誊抄。
二
任意选择一个文本文件，采用并发进程实现文件誊抄，将其复制为另一个文件。
创建get、copy、put三个进程共用两个缓冲区s、t。get进程负责不断地把原始文件内容送入缓冲区s中，copy进程负责从缓冲区s中取出上述内容复制到缓冲区t中，而put进程负责把上述内容从缓冲区t中取出复制到目标文件中，用p、v操作实现这三个进程之间的同步。
}
int V(int semid, int semnum) {
struct sembuf sops = {semnum, +1, SEM_UNDO};
return (semop(semid, &sops, 1));
}
int main()
{
//定义共享缓冲区，获得一个共享内存的标志，新建内存为1KB
int readbuf_id=shmget(231,CACHE_LENGTH,IPC_CREAT|0666);
}
}
//put_porcess
if((put_id=fork())==0){
if((fout=fopen("./put.txt","wb"))==NULL)
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：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）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
《操作系统》实验二
《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解，通过实际操作，提高对操作系统设计和实现的认知。
通过实验二，我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。
b.设计一个简单的进程调度算法，如轮转法或优先级调度法。
c.实现进程间的通信机制，如共享内存或消息队列。
2、线程调度a.实现线程的创建、撤销和调度。
b.实现一个简单的线程调度算法，如协同多任务（cooperative multitasking）。
3、内存管理a.设计一个简单的分页内存管理系统。
b.实现内存的分配和回收。
c.实现一个简单的内存保护机制。
4、文件系统a.设计一个简单的文件系统，包括文件的创建、读取、写入和删除。
b.实现文件的存储和检索。
c.实现文件的备份和恢复。
三、实验步骤1、进程管理a.首先，设计一个进程类，包含进程的基本属性（如进程ID、状态、优先级等）和操作方法（如创建、撤销、阻塞、唤醒等）。
b.然后，实现一个进程调度器，根据不同的调度算法对进程进行调度。
可以使用模拟的方法，不需要真实的硬件环境。
c.最后，实现进程间的通信机制，可以通过模拟共享内存或消息队列来实现。
2、线程调度a.首先，设计一个线程类，包含线程的基本属性（如线程ID、状态等）和操作方法（如创建、撤销等）。
b.然后，实现一个线程调度器，根据不同的调度算法对线程进行调度。
同样可以使用模拟的方法。
3、内存管理a.首先，设计一个内存页框类，包含页框的基本属性（如页框号、状态等）和操作方法（如分配、回收等）。
b.然后，实现一个内存管理器，根据不同的内存保护机制对内存进行保护。
可以使用模拟的方法。
4、文件系统a.首先，设计一个文件类，包含文件的基本属性（如文件名、大小等）和操作方法（如创建、读取、写入、删除等）。
b.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
操作系统lab2实验报告
二、目的
1.理解基于段页式内存地址的转换机制；
2.理解页表的建立和使用方法；
3.理解物理内存的管理方法。
三、实验设计思想和练习题
练习0：填写已有实验
使用eclipse中的diff/merge工具将实验1的代码填入本实验中代码中有“LAB1”的注释相应部分。
练习1：实现first-fit连续物理内存分配算法（需要编程）
list_entry：双向链表指针，指向空闲的物理页；
nr_free：记录当前空闲页的个数的无符号整形变量。
（2）连续物理内存分配思路：
物理内存页管理器顺着双向链表进行搜索空闲内存区域，直到找到一个足够大的空闲区域，这是一种速度很快的算法，因为它尽可能少地搜索链表。如果空闲区域的大小和申请分配的大小正好一样，则把这个空闲区域分配出去，成功返回;否则将该空闲区分为两部分，一部分区域与申请分配的大小相等，把它分配出去，剩下的一部分区域形成新的空闲区。其释放内存的设计思路是把这块区域重新放回双向链表中。
（2）如果找到，获得指向分配的页，重新设置标志位，从空闲链表中删除此页；
（3）判断空闲块大小是否合适；
（4）如果合适，不操作；如果不合适，分割页块；
ห้องสมุดไป่ตู้（5）计算剩余空闲页个数，返回分配的页块地址。
B．具体实现：
注：
算法改进空间：第一页重置标志位操作被注释后，依然可以编译运行。
操作系统lab2实验报告
操作系统lab2实验报告操作系统 Lab2 实验报告一、实验目的本次实验着重学习操作系统内存管理的相关概念和技术，包括页表的建立和管理，以及虚拟内存系统的实现和优化。
通过完成本实验，我们能够加深对操作系统内存管理机制的理解，并掌握相关的实现方法。
二、实验环境本次实验使用的实验环境为 Linux 操作系统（具体版本号）、GCC 编译器（具体版本号）以及所提供的模拟器。
三、实验内容本次实验主要包括以下几个任务：1. 理解虚拟内存和物理内存的概念，掌握页表的结构和管理方法。
2. 编写代码实现一个简单的页表建立和管理的模拟器，包括页表的初始化、地址映射和页表的更新。
3. 实现一个简单的虚拟内存系统，包括页的加载、替换等操作。
4. 对实现的虚拟内存系统进行性能优化，包括缓存算法的改进、预加载等策略的应用。
四、实验步骤及结果1. 理解虚拟内存和物理内存的概念在本次实验中，我们将使用虚拟内存系统来管理进程的地址空间。
虚拟内存是操作系统提供给进程的一种抽象概念，它为每个进程提供了一个独立的、连续的地址空间。
物理内存是实际存在的计算机内存，由物理地址组成。
2. 编写页表管理模拟器代码根据实验要求，我们需要编写代码模拟页表的建立和管理过程。
首先，我们需要实现页表的初始化函数，用于初始化页表的数据结构。
接着，我们需要实现地址映射函数，用于将虚拟地址映射到物理地址。
最后，我们需要实现页表的更新函数，用于更新页表中的相关信息。
3. 实现虚拟内存系统在本次实验中，我们需要实现一个简单的虚拟内存系统。
虚拟内存系统可以将虚拟地址映射到物理地址，并且可以实现页的加载和替换操作。
我们需要实现页面加载函数，用于将页面加载到内存中。
同时，我们还需要实现页面替换函数，当内存空间不足时，根据特定的算法选择待替换的页，并将其移出内存。
4. 性能优化为了提高虚拟内存系统的性能，我们可以采用一些优化策略。
例如，我们可以改进缓存算法，通过提前缓存一些可能会被访问的页面，减少缺页次数。
操作系统课程实验报告
操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。
通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。
在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。
2、进程同步与互斥使用信号量实现进程之间的同步与互斥。
在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。
（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。
在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。
2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。
（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。
2、目录操作实现了目录的创建、删除、遍历等功能。
四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。
操作系统2实验3报告
实验（三）请求页式存储管理实验目的：近年来，由于大规模集成电路（LSI）和超大规模集成电路（VLSI）技术的发展，使存储器的容量不断扩大，价格大幅度下降。
但从使用角度看，存储器的容量和成本总受到一定的限制。
所以，提高存储器的效率始终是操作系统研究的重要课题之一。
虚拟存储技术是用来扩大内存容量的一种重要方法。
学生应独立地用高级语言编写几个常用的存储分配算法，并设计一个存储管理的模拟程序，对各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
实验内容：为了比较真实地模拟存储管理，可预先生成一个大致符合实际情况的指令地址流。
然后模拟这样一种指令序列的执行来计算和分析各种算法的访问命中率。
本实验采用页式分配存储管理方案，并通过分析计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣。
另外也考虑到改变页面大小和实际存储器容量对计算结果的影响，从而可为算则好的算法、合适的页面尺寸和实存容量提供依据。
实验是按下述原则生成指令序列的：(1) 50%的指令是顺序执行的。
(2) 25%的指令均匀散布在前地址部分。
(3) 25%的指令均匀散布在后地址部分。
示例中选用最佳淘汰算法（OPT）和最近最少使用页面淘汰算法（LRU）计算页面命中率。
公式为假定虚存容量为32K，页面尺寸从1K至8K，实存容量从4页至32页。
（1）最佳淘汰算法（OPT）这是一种理想的算法，可用来作为衡量其他算法优劣的根据，在实际系统中是难以实现的，因为它必须先知道指令的全部地址流。
由于本示例中已预生成了全部的指令地址流，故可计算出最佳命中率。
该算法的准则是淘汰已满页表中不再访问或是最迟访问的的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不在访问该页，则把此页淘汰，不然得找出后继指令中最迟访问的页面淘汰。
可见最佳淘汰算法要花费比较长的运算时间。
（2）最近最少使用页淘汰算法（LRU）这是一种经常使用的方法，有各种不同的实施方案，这里采用的是不断调整页表链的方法，即总是淘汰页表链链首的页，而把新访问的页插入链尾。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
评分：SHANGHAI UNIVERSITY操作系统实验报告学院计算机工程与科学专业计算机科学与技术学号学生姓名《计算机操作系统》实验一报告实验一题目：操作系统的进程调度姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： Microsoft Visual Studio实验目的：进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。
本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。
调度算法可任意选择或自行设计。
例如，简单轮转法和优先数法等。
本实习可加深对于进程调度和各种调度算法的理解。
实验内容：1、设计一个有n个进程工行的进程调度程序。
每个进程由一个进程控制块（PCB）表示。
进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。
2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。
3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。
操作过程：1、本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。
为了便于处理，程序进程的运行时间以时间片为单位计算。
进程控制块结构如下：进程控制块结构如下：PCB进程标识数链指针优先数/轮转时间片数占用 CPU 时间片数进程所需时间片数进程状态进程控制块链结构如下：其中：RUN—当前运行进程指针；HEAD—进程就绪链链首指针；TAID—进程就绪链链尾指针。
2、算法与框图(1) 优先数法。
进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2) 简单轮转法。
进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
(3) 程序框图运行结果：Priority算法：Round Robin算法：实验代码：//操作系统实验--进程调度#include <cstdio>#include <ctime>#include <cstring>#include <cstdlib>const long n=5;struct pcbtype //进程控制块结构{long id, priority, runtime, totaltime;char status; //R, W, F -> 运行，就绪，完成}PCB[n+1];long link[n+1]; //链表结构long RUN, HEAD, TAIL;//选择算法long ChooseAlgo(){实验体会：通过写代码的过程更加清晰地了解了两种算法的思想和用处，对算法的了解加深的同事也锻炼了写代码的能力。
《计算机操作系统》实验三报告实验三题目：请求页式存储管理姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： Microsoft Visual Studio实验目的：近年来，由于大规模集成电路（LSI）和超大规模集成电路（VLSI）技术的发展，使存储器的容量不断扩大，价格大幅度下降。
但从使用角度看，存储器的容量和成本总受到一定的限制。
所以，提高存储器的效率始终是操作系统研究的重要课题之一。
虚拟存储技术是用来扩大内存容量的一种重要方法。
学生应独立地用高级语言编写几个常用的存储分配算法，并设计一个存储管理的模拟程序，对各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
实验内容：为了比较真实地模拟存储管理，可预先生成一个大致符合实际情况的指令地址流。
然后模拟这样一种指令序列的执行来计算和分析各种算法的访问命中率。
本实验采用页式分配存储管理方案，并通过分析计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣。
另外也考虑到改变页面大小和实际存储器容量对计算结果的影响，从而可为算则好的算法、合适的页面尺寸和实存容量提供依据。
实验是按下述原则生成指令序列的：(1) 50%的指令是顺序执行的。
(2) 25%的指令均匀散布在前地址部分。
(3) 25%的指令均匀散布在后地址部分。
示例中选用最佳淘汰算法（OPT）和最近最少使用页面淘汰算法（LRU）计算页面命中率。
公式为假定虚存容量为32K，页面尺寸从1K 至8K，实存容量从4 页至32 页。
（1）最佳淘汰算法（OPT）这是一种理想的算法，可用来作为衡量其他算法优劣的根据，在实际系统中是难以实现的，因为它必须先知道指令的全部地址流。
由于本示例中已预生成了全部的指令地址流，故可计算出最佳命中率。
该算法的准则是淘汰已满页表中不再访问或是最迟访问的的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不在访问该页，则把此页淘汰，不然得找出后继指令中最迟访问的页面淘汰。
可见最佳淘汰算法要花费比较长的运算时间。
（2）最近最少使用页淘汰算法（LRU）这是一种经常使用的方法，有各种不同的实施方案，这里采用的是不断调整页表链的方法，即总是淘汰页表链链首的页，而把新访问的页插入链尾。
如果当前调用页已在页表内，则把它再次调整到链尾。
这样就能保证最近使用的页，总是处于靠近链尾部分，而不常使用的页就移到链首，逐个被淘汰，在页表较大时，调整页表链的代价也是不小的。
操作过程：运行结果：最近最少使用：最佳淘汰：实验体会：通过这次实验，我了解了采用页式分配存储管理方案，并对页式分配存储管理的两个算法最佳淘汰算法和最近最少使用页淘汰算法有了更深入的了解，为之后的学习奠定了基础。
《计算机操作系统》实验四报告实验四题目：文件操作与管理姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： Microsoft Visual Studio实验目的：随着社会信息量的极大增长，要求计算机处理的信息与日俱增，涉及到社会生活的各个方面。
因此，文件管理是操作系统的一个极为重要的组成部分。
学生应独立地用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深理解课堂上讲授过的知识。
实验内容：1.要求：（1）实际一个 n 个用户的文件系统，每个用户最多可保存 m 个文件。
（2）限制用户在一次运行中只能打开 l 个文件。
（3）系统应能检查打入命令的正确性，出错要能显示出错原因。
（4）对文件必须设置保护措施，如只能执行，允许读、允许写等。
在每次打开文件时根据本次打开的要求，再次设置保护级别，即可有二级保护。
（5）对文件的操作至少应有下述几条命令：creat 建立文件。
delete 删除文件。
open 打开文件。
close 关闭文件。
read 读文件。
write 写文件。
2.示例：（1）程序采用二级文件目录，即设置了主文件目录（MFD）和用户文件目录（UFD）。
前者应包含文件主（即用户）及他们的目录区指针；后者应给出每个文件主占有的文件目录，即文件名，保护码，文件长度以及他们存放的位置等。
另外为打开文件设置了运行文件目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。
3.算法与框图（1）因系统小，文件目录的检索使用了简单的线性搜索，而没有采用 Hash 等有效算法。
（2）文件保护简单实用了三位保护码，对应于允许读、允许写和运行执行，如下所示：1 1 1允许写允许读允许执行如对应位为 0，则不允许。
实验源码：cout<<"input the command:"<<endl;break;}}}return 0;}实验结果：实验体会：本次实验主要是模拟了一下文件系统，文件是我们平时接触最多也是最广的形式，即便是不会计算机的人们也可以通过这种操作文件来很方便地完成操作，而本次实验让我了解到了文件系统的内部实现，虽然仅仅是通过C++模拟的，但还是让我对它的原理有了更好的理解，也是对我们上课的内容的一个巩固。
《计算机操作系统》实验六报告实验六题目： FAT 文件系统实验姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： win95 虚拟机实验目的：从系统分析的角度出发，了解FAT 文件系统的组织结构和文件的存储方式。
进一步理解操作系统文件管理的基本思想。
实验内容：1.了解3 吋软盘的FAT 文件系统结构。
2.察看文件分配表的簇号链。
3.察看文件目录表中文件目录结构。
4.了解用簇号链映射的文件链式存储结构。
5.分析目录文件的组成。
实验步骤：1. 进入DEBUG 环境，装入FAT 文件系统结构。
执行命令：L 0 0 0 21说明：将0 号驱动器中，逻辑扇区号从0 开始的共21H 个扇区读入内存，放在DS:0000 为起始的地址中。
2．观察1.44M 软盘中FAT12 文件系统结构。
执行命令：D 0000连续执行D 命令，每次显示128 个字节，可见文件系统结构。
FAT 文件系统结构如下：逻辑扇区号其中：Boot 引导程序FAT 文件分配表FDT 文件目录表1.44M 软盘逻辑扇号与物理扇区的对应关系逻辑扇号0 # ——0 道0 面 1 扇逻辑扇号1 H ~11H ——0 道0 面2 ~18 扇逻辑扇号12 H ~23H ——0 道1 面1 扇~18 扇逻辑扇号24 H ~35H ——1 道0 面1 扇~18 扇软盘有两面，每面80 个磁道，每个磁道18 个扇区，每个扇区512 个字节，所以软盘的容量是2*80*18*512 = 1474560, 1474560/1024/1024 大约为1.44M。
3．分析文件分配表结构，了解用簇链映射的文件的链式存储结构。
执行命令：D 200思考：上面屏幕显示首簇号为003 的文件共包括几个扇区？它分布在哪几个物理扇区上？答：首簇号为003 的文件共包括2 个扇区，它分布在0 道0 面2、3 扇。