下载文档原格式
电子科技大学计算机学院实验中心小心计算机专业类课程实验报告课程名称：操作系统学 院：软件学院专 业：软件工程学生姓名：李 希学 号：2010231020018指导教师：丁老师日 期： 2012年5月5日电子科技大学实验报告实验一一、实验名称：进程管理二、实验学时：4三、实验内容和目的：实验内容：（1）进程的创建写一段源程序，创建两个进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示字符。
观察纪录屏幕上的显示结果，然后分析原因。
（2）进程的控制修改编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。
实验目的：（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）分析进程竞争资源现象，学习解决进程互斥的方法。
四、实验原理：利用fork函数来创建子进程，并返回子进程的ID号。
利用lockf函数来实现信号量对进程的资源竞争的调度，和互斥的方法。
五、实验器材（设备、元器件）:一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤：（1）先写好2个子进程程序，并且让2个子程序在屏幕上分别打印出A,B（2）父进程创建2个子进程，并在屏幕上打印出C。
（3）观察进程竞争资源的现象。
七、实验数据及结果分析：电子科技大学计算机学院实验中心子进程A的代码：#include<iostream>#include<windows.h>using namespace std;int main(){cout<<"I'm Process A/n"<<endl;return 0;}子进程B的代码：#include<iostream>using namespace std;int main(){cout<<"I'm Process B"<<endl;;return 0;}父进程C的代码：//#include "stdafx.h"#include<windows.h>#include<iostream>using namespace std;void print_error(){DWORD nErrorNo = GetLastError ( );LPSTR lpBuffer;FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS |FORMAT_MESSAGE_FROM_SYSTEM,NULL,nErrorNo,LANG_NEUTRAL,(LPTSTR) & lpBuffer,0 ,NULL );if (lpBuffer == NULL){lpBuffer = "Sorry, cannot find this error info. ";}printf("%s (%d).\n", lpBuffer, nErrorNo);}int fork(const char* pszApplication,HANDLE& hProcess){STARTUPINFO si={sizeof(si)};PROCESS_INFORMATION pi;if(!CreateProcess(pszApplication,NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi)) return -1;else{hProcess=pi.hProcess;return pi.dwProcessId;}}void lockf(HANDLE hObj){DWORD state = WaitForSingleObject(hObj,INFINITE);switch (state){case WAIT_OBJECT_0:printf("\nProcess exit.\n");break;case WAIT_TIMEOUT:printf("\nTime out.\n");break;case WAIT_FAILED:printf("\nWait Failed.\n");print_error();break;}}int main(int argc, char* argv[]){HANDLE hProcess1,hProcess2;int child1=fork("C:\\操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦\\ProcessA\\Debug\\ProcessA.exe",hProcess1);if(-1==child1){cout << "fork error!\n";return -1;}lockf(hProcess1);电子科技大学计算机学院实验中心int child2=fork("C:\\操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦\\ProcessB\\Debug\\ProcessB.exe",hProcess2);if(-1==child2){cout << "fork error!\n";return -1;}cout<<"This is Process C\n";lockf(hProcess2);return 0;}程序运行的结果：八、实验结论、心得体会和改进建议：实验结论：成功的通过了父进程C来创建了2个子进程A,B，并成功的对子进程进行了调度与管理。
操作系统的内存分页和虚拟内存实现内存的分页和虚拟内存的管理操作系统中的内存管理是计算机系统中至关重要的一部分。
在大部分计算机系统中，内存被划分为一系列连续的内存块，用于存储正在执行的程序、数据和系统内核。
然而，由于内存容量的限制和多任务操作系统的需要，操作系统需要采取一些技术来实现内存的分页和虚拟内存的管理。
本文将介绍操作系统中内存分页和虚拟内存的实现原理和管理方法。
一、内存分页的实现内存分页是操作系统中一种常见的内存管理技术。
它将物理内存和逻辑内存划分为固定大小的块，称为页。
每个页的大小通常为2的幂，例如4KB或8KB。
当程序加载到内存时，它会被分割成与页大小相匹配的若干页，每个页都被映射到内存中的一个页帧。
这种方式可以提高内存的利用率，减少碎片化问题。
在内存分页的实现中，操作系统会维护一个页表来跟踪每个页的映射情况。
页表中的每个表项包含了页号和页帧号的对应关系。
当程序需要访问一个逻辑地址时，操作系统先通过页表查找对应的页帧号，然后将逻辑地址转换为物理地址，最后将数据加载到内存中。
内存分页的实现需要支持页表的生成和维护，还需要处理内存地址的转换和访问权限的控制。
操作系统通常会使用硬件中的内存管理单元（MMU）来加速地址转换的过程。
MMU可以通过页表的基址寄存器和逻辑地址的偏移量，直接计算出物理地址，提高地址转换的效率。
二、虚拟内存的实现虚拟内存是一种在物理内存不足的情况下，将部分数据存储到磁盘上的技术。
它为每个进程提供了独立的地址空间，使得每个进程感觉自己独占了整个内存空间。
当进程访问虚拟内存中的数据时，操作系统会根据需求将数据从磁盘加载到内存中。
虚拟内存的实现依赖于操作系统中的内存管理单元（MMU）和页面置换算法。
当进程访问一个未加载到内存中的页时，MMU会触发缺页异常，操作系统需要根据页面置换算法来选择一些页将其从内存中换出，腾出空间来加载新的页。
常见的页面置换算法包括最佳置换算法（OPT）、先进先出置换算法（FIFO）、最近最久未使用置换算法（LRU）等。
实验二主存储器空间的分配和回收一、实验题目：模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。
二、实验目的：主存的分配和回收的实现与主存储器的管理方式有关，通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验内容：一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
四、程序中使用的数据结构及符号说明：五、程序流程图：六、程序源代码：#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，编程语言为 Python 38。
实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。
2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。
3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。
当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性，生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。
平均周转时间：作业从到达系统到完成的时间间隔的平均值。
系统吞吐量：单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。
课程实验报告
在单处理机的情况下模拟用优先权的时间片轮转调度策略实现处理机调度，以加深了解处理机调度的工作过程。
要求：
可利用先来先服务、短作业优先、响应比高者优先、多级反馈队列模型、时间片轮转法等，来实现处理机的调度。
根据单处理机，多任务的问题特性做好软件实现的需求分析。
可根据问题的实际需要，可选择进程数量。
当系统运行时，能直观地、动态地反映当前处理机状态及各进程执行的状况。
描述6.create函数用于创建队列
7.insert为插入函数，用于将一个时间片运行结束的进程插入到就绪进程的
队尾
8.priority函数：如果有进程就绪，就将处理机分配给该进程让他执行。
调试过程及实验结果
总结每次运行一步，电脑将会将该时刻所有进程控制块的运行状态显示给用户。
包括进程名、要求运行时间、已经运行时间、还需要运行时间、状态等信息。
当每个进程运行一个时间片之后将它从该队列中移除，添加到就绪队列队尾中以便使每个进程可以循环执行。
当要求运行时间和已运行时间相等时，说明该进程运行结束，将该进程撤出该队列并且不再添加到就绪队列中。
直到就绪队列中没有就绪进程为止
附录#define _CRT_SECURE_NO_DEPRECATE #include"stdio.h"
#include"stdlib.h"
#include"string.h"
typedef struct node
{
char pname[10]; //进程名
int rtime; //已运行时间
int sytime; //剩余时间。
操作系统实验-存储管理操作系统实验-存储管理1、引言1.1 概述在操作系统中，存储管理是一个关键的任务。
它负责将程序和数据加载到内存中，管理内存的分配和回收，并确保不同进程之间的内存互不干扰。
本实验旨在深入了解并实践存储管理的相关概念和算法。
1.2 目的本实验的目的是让学生通过实际操作，了解存储管理的基本原理和常用算法，包括分页、分段和虚拟内存等。
通过实验，学生将学会如何实现内存分配和回收，以及处理内存碎片等问题。
1.3 实验环境- 操作系统：Windows、Linux、MacOS等- 编程语言：C、C++等2、实验步骤2.1 实验准备- 安装相应的开发环境和工具- 创建一个空白的项目文件夹，用于存放实验代码和相关文件2.2 实验一、分页存储管理- 理解分页存储管理的概念和原理- 实现一个简单的分页存储管理系统- 设计测试用例，验证分页存储管理的正确性和有效性2.3 实验二、分段存储管理- 理解分段存储管理的概念和原理- 实现一个简单的分段存储管理系统- 设计测试用例，验证分段存储管理的正确性和有效性2.4 实验三、虚拟存储管理- 理解虚拟存储管理的概念和原理- 实现一个简单的虚拟存储管理系统- 设计测试用例，验证虚拟存储管理的正确性和有效性3、实验结果分析3.1 分页存储管理结果分析- 分析分页存储管理系统的性能优缺点- 比较不同页面大小对系统性能的影响3.2 分段存储管理结果分析- 分析分段存储管理系统的性能优缺点- 比较不同段大小对系统性能的影响3.3 虚拟存储管理结果分析- 分析虚拟存储管理系统的性能优缺点- 比较不同页面置换算法对系统性能的影响4、总结与展望4.1 实验总结- 总结本次实验的收获和体会- 分析实验中遇到的问题和解决方法4.2 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件：无法律名词及注释：- 存储管理：操作系统中负责管理内存的任务，包括内存分配、回收和管理等功能。
一、实验目的1. 理解处理器调度的基本概念和原理；2. 掌握常用的处理器调度算法，如先来先服务（FCFS）、短作业优先（SJF）、优先级调度等；3. 分析不同调度算法的性能指标，如平均周转时间、平均带权周转时间等；4. 通过实验，提高实际操作和编程能力。
二、实验原理处理器调度是操作系统中的一个重要组成部分，其主要任务是合理分配处理器资源，使系统中的多个进程高效、有序地运行。
常见的处理器调度算法有以下几种：1. 先来先服务（FCFS）：按照进程到达就绪队列的顺序进行调度，先到先服务；2. 短作业优先（SJF）：优先选择运行时间最短的进程执行；3. 优先级调度：根据进程的优先级进行调度，优先级高的进程先执行；4. 时间片轮转（RR）：将每个进程分配一个时间片，按照时间片轮转的方式调度进程。
三、实验内容1. 实验环境：Windows操作系统，Python编程语言；2. 实验工具：Python编程环境，如PyCharm、Spyder等；3. 实验步骤：（1）设计一个进程类，包含进程名、到达时间、运行时间、优先级等属性；（2）编写调度算法，实现FCFS、SJF、优先级调度和时间片轮转算法；（3）模拟进程执行过程，记录各个进程的执行时间、等待时间、周转时间等性能指标；（4）分析不同调度算法的性能，比较其优劣。
四、实验结果与分析1. FCFS调度算法实验结果：平均周转时间为20，平均带权周转时间为1.25。
分析：FCFS调度算法简单易实现，但可能导致进程响应时间长，不利于实时性要求高的系统。
2. SJF调度算法实验结果：平均周转时间为16，平均带权周转时间为1.2。
分析：SJF调度算法可以缩短平均周转时间，提高系统性能，但可能使长作业长时间等待，影响公平性。
3. 优先级调度算法实验结果：平均周转时间为18，平均带权周转时间为1.3。
分析：优先级调度算法可以根据进程的优先级进行调度，提高系统响应速度，但可能导致低优先级进程长时间等待。
处理机调度算法实验报告学号姓名时间专业班级实验题目：处理机调度算法一、实验目的在了解操作系统的基础上全面了解处理机调度算法的实现以及过程，详细了解处理机调度算法的机制，充分了解调度的过程及状态，采用优先数法进程调度算法来模拟演示进程调度二、实验内容与步骤：1. 了解进程的三种状态状态：ready、running、finish2.了解进程需要的CPU时间以时间片为单位确定3.编写一段程序#include <stdio.h>#include <stdlib.h>#define P_NUM 5#define P_TIME 50enum state{ready,execute,block,finish};struct pcbb{char name[4];int priority;int cputime;int needtime;int count;enum state process;struct pcbb *next;};typedef struct pcbb pcb;void display_menu(){printf("CHOOSE THE ALGORITHM:\n");printf("1 PRIORITY\n");printf("2 ROUNDROBIN\n");printf("3 EXIT\n");}pcb* get_process(){pcb *q;pcb *p;pcb *t;int i = 0;printf("input name and time\n");while (i < P_NUM){q=(pcb *)malloc(sizeof(pcb));scanf("%s",q->name);scanf("%d",&q->needtime);q->cputime = 0;q->priority = P_TIME - q->needtime;q->process = ready;q->next = NULL;if(i==0){p = q;t = q;}else{t->next = q;t = q;}i++;}return p;}void free_process(pcb *p){pcb *q;while(p!= NULL){q = p;p = p->next;free(q);}}void display(pcb *p){printf("name cputime needtime priority state\n");while(p){printf("%s",p->name);printf(" ");printf("%d",p->cputime);printf(" ");printf("%d",p->needtime);printf(" ");printf("%d",p->priority);printf(" ");switch(p->process){case ready:printf("ready\n");break;case execute:printf("execute\n"); break;case block:printf("block\n"); break;case finish:printf("finish\n"); break;}p = p->next;}}int process_finish(pcb *q){int b1 = 1;while(b1&&q){b1 = b1&&q->needtime==0;q = q->next;}return b1;}void cpuexe(pcb *q){pcb *t = q;int tp = 0;while(q){if (q->process!=finish){q->process = ready;if(q->needtime==0){q->process = finish;}}if(tp<q->priority&&q->process!=finish){tp = q->priority;t = q;}q = q->next;}if(t->needtime!=0){t->priority -=3;t->needtime --;t->process = execute;t->cputime++;}}void priority_cal(){pcb *p;p = get_process();int cpu = 0;while(!process_finish(p)){cpu++;printf("cputime:%d\n",cpu);cpuexe(p);display(p);sleep(2);}free_process(p);printf("All processes have finished\n"); }pcb *get_process_round(){pcb *q;pcb *p;pcb *t;int i = 0;printf("input name and time\n");while (i<P_NUM){q=(pcb *)malloc(sizeof(pcb));scanf("%s",q->name);scanf("%d",&q->needtime);q->cputime = 0;q->count = 0;q->process = ready;q->next = NULL;if(i==0){p = q;t = q;}else{t->next = q;t = q;}i++;}return p;}void cpu_round(pcb *q){if(q->needtime==1)q->cputime++;elseq->cputime +=2;q->needtime -=2;if(q->needtime<0){q->needtime = 0;}q->count++;q->process = execute;}pcb *get_next(pcb *k,pcb *head){pcb *t;t = k;do{t =t->next;}while ( t && t->process == finish);if(t == NULL){t = head;while(t->next!=k && t->process == finish){t = t->next; } }return t;}void set_state(pcb *p){while(p){if(p->needtime == 0){p->process = finish;}if(p->process == execute){p->process = ready; }p = p->next; }}void display_round(pcb *p){printf("name cputime needtime count state\n");while(p){printf("%s",p->name);printf(" ");printf("%d",p->cputime);printf(" ");printf("%d",p->needtime);printf(" ");printf("%d",p->count);printf(" ");switch(p->process){case ready:printf("ready\n");break;case execute:printf("execute\n"); break;case block:printf("block\n"); break;case finish:printf("finish\n"); break; }p = p->next; }}void round_cal(){pcb *p;pcb *r;p = get_process_round();int cpu = 0;r=p;while(!process_finish(p)){if(r->needtime==1)cpu+=1;elsecpu+=2;cpu_round(r);r = get_next(r,p);printf("cputime:%d\n",cpu);display_round(p);set_state(p);sleep(2);}free_process(p); }main(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;default:printf("YOU HA VE NOT CHOOSE ANY ALGORITHM!\n");}}运行后结果如下：[root@rhel5hbzy ~]# gcc -o chuliji chuliji.c[root@rhel5hbzy ~]# ./mCHOOSE THE ALGORITHM:1 PRIORITY2 ROUNDROBIN3 EXIT1input name and timejing 2aaaa 8bbbb5ffff4ggg 6cputime:1name cputime needtime priority state jing- 1 1 45 execute aaaa* 0 8 42 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 0 6 44 ready rtyucputime:2name cputime needtime priority state jing* 2 0 42 execute aaaa* 0 8 42 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 0 6 44 ready 5cputime:3name cputime needtime priority state jing* 2 0 42 finish aaaa* 0 8 42 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 1 5 41 execute 2cputime:4name cputime needtime priority state jing* 2 0 42 finish aaaa' 1 7 39 execute bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 1 5 41 readycputime:5name cputime needtime priority state jing* 2 0 42 finish aaaa' 1 7 39 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 2 4 38 execute cputime:6name cputime needtime priority state jing* 2 0 42 finish aaaa$ 2 6 36 execute bbbb2 0 0 50 finish ffff2 0 0 50 finishggg 2 4 38 ready cputime:7name cputime needtime priority state jing* 2 0 42 finish aaaa$ 2 6 36 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 3 3 35 execute cputime:8name cputime needtime priority state jing* 2 0 42 finish aaaa! 3 5 33 execute bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 3 3 35 ready cputime:9name cputime needtime priority state jing* 2 0 42 finish aaaa! 3 5 33 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 4 2 32 execute cputime:10name cputime needtime priority state jing* 2 0 42 finish aaaa- 4 4 30 execute bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 4 2 32 ready cputime:11name cputime needtime priority state jing* 2 0 42 finish aaaa- 4 4 30 ready bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 5 1 29 execute cputime:12name cputime needtime priority state jing* 2 0 42 finish aaaa 5 3 27 execute bbbb2 0 0 50 finish ffff2 0 0 50 finish ggg 5 1 29 ready cputime:13name cputime needtime priority statejing* 2 0 42 finishaaaa 5 3 27 readybbbb2 0 0 50 finishffff2 0 0 50 finishggg 6 0 26 execute cputime:14name cputime needtime priority statejing* 2 0 42 finishaaaa 6 2 24 executebbbb2 0 0 50 finishffff2 0 0 50 finishggg 6 0 26 finish3cputime:15name cputime needtime priority statejing* 2 0 42 finishaaaa 7 1 21 executebbbb2 0 0 50 finishffff2 0 0 50 finishggg 6 0 26 finish cputime:16name cputime needtime priority statejing* 2 0 42 finishaaaa 8 0 18 executebbbb2 0 0 50 finishffff2 0 0 50 finishggg 6 0 26 finishAll processes have finished[root@rhel5hbzy ~]# rtyu2bash: rtyu2: command not found[root@rhel5hbzy ~]# 3bash: 3: command not found三、分析与体会多道程序设计中，通常是若干个进程同时处于就绪状态，必须依照某种策略来决定哪个进程优先占有处理机。
处理器调度实验报告处理器调度实验报告一、实验目的处理器调度是操作系统中的重要组成部分，它负责决定哪个进程优先执行，以及如何分配处理器资源。
本次实验旨在通过模拟不同的处理器调度算法，深入了解各种算法的工作原理和优缺点。
二、实验背景在多道程序设计环境下，多个进程同时竞争有限的处理器资源。
为了提高系统的吞吐量和响应速度，需要合理地调度进程，使得每个进程都能得到公平的执行机会。
处理器调度算法的选择直接影响到系统的性能和用户体验。
三、实验内容本次实验使用模拟器来模拟不同的处理器调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority Scheduling）。
通过对这些算法的模拟实验，我们可以观察到它们在不同场景下的表现。
四、实验过程与结果首先，我们设计了一组测试用例，每个测试用例包含若干个进程，每个进程具有不同的执行时间和优先级。
然后，我们分别使用不同的调度算法对这些进程进行调度，并记录下每个进程的等待时间和周转时间。
在FCFS算法下，进程按照到达的先后顺序依次执行。
这种算法简单直观，但是容易造成后面进程的等待时间过长，尤其是当某个进程执行时间较长时。
SJF算法根据进程的执行时间来进行调度，执行时间最短的进程先执行。
这种算法能够最大程度地减少平均等待时间，但是对于长作业来说，可能会出现饥饿现象。
RR算法将处理器的时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程。
这种算法能够保证每个进程都能得到执行的机会，但是对于执行时间较长的进程来说，可能会造成较大的上下文切换开销。
优先级调度算法根据进程的优先级来进行调度，优先级高的进程先执行。
这种算法可以根据不同的场景进行调整，但是可能会出现优先级反转的问题。
通过实验结果的分析，我们可以看到不同的调度算法在不同场景下的表现。
对于短作业来说，SJF算法能够最大程度地减少等待时间；对于长作业来说，RR算法能够保证公平性；而优先级调度算法则适用于一些需要特定优先级处理的场景。
《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解，通过实际操作，提高对操作系统设计和实现的认知。
通过实验二，我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容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.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
