操作系统实验二——cpu调度与内存分页

电子科技大学计算机学院实验中心小心计算机专业类课程实验报告课程名称：操作系统学 院：软件学院专 业：软件工程学生姓名：李 希学 号：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.然后，实现一个文件系统管理器，包括文件的存储和检索功能。

操作系统页面调度算法程序实验报告一、实验背景操作系统是计算机系统中最重要的组成部分之一，它负责管理计算机的资源、协调各个程序的运行和提供用户与计算机之间的接口。

而页面调度算法则是操作系统中非常重要的一个部分，它主要用于管理内存中的页面，以提高计算机系统的性能和效率。

二、实验目的本次实验旨在通过编写一个页面调度算法程序，深入理解操作系统中页面调度算法的原理和实现方法，并掌握如何使用C语言进行程序设计和开发。

三、实验原理1. 页面调度算法概述在操作系统中，为了提高内存利用率和进程执行效率，通常会将进程所需的数据或指令分割成多个大小相等的块（即“页面”），并将这些页面存储到内存中。

当进程需要访问某个页面时，如果该页面已经在内存中，则直接访问即可；如果该页面不在内存中，则需要进行“缺页处理”，将其从磁盘读入内存，并将其中一个已经在内存中但未被访问过一段时间的页面替换出去。

而为了确定应该替换哪个页面，就需要使用一种称为“页面调度算法”的技术来进行决策。

常见的页面调度算法有FIFO、LRU、LFU等。

2. FIFO算法FIFO（First In First Out）算法是最简单的页面调度算法之一，它的原理是将最先进入内存的页面替换出去。

具体来说，当一个新页面需要进入内存时，如果内存已经满了，则将最先进入内存的页面替换出去，并将新页面插入到队列末尾。

3. LRU算法LRU（Least Recently Used）算法是一种比较常用的页面调度算法，它的原理是根据页面最近被访问的时间来进行决策。

具体来说，当一个新页面需要进入内存时，如果内存已经满了，则将最近访问时间最早且未被修改过的页面替换出去，并将新页面插入到队列末尾。

4. LFU算法LFU（Least Frequently Used）算法是一种根据页面使用频率来进行决策的调度算法。

具体来说，当一个新页面需要进入内存时，如果内存已经满了，则将使用频率最低的那个页面替换出去，并将新页面插入到队列末尾。

实验二内存管理实验一、实验目的1．掌握基本的主存分配和回收算法，了解Windows 2000/XP的虚拟内存机制。

2．学习使用Windows 2000/XP的与内存相关的API函数。

3．掌握请求分页存储管理方式。

二、实验内容及要求1．实验内容使用Windows 2000/XP 的API 函数，创建两个线程，一个用于模拟内存的分配活动，一个用于跟踪并记录内存分配过程中的内存变化情况，要求这两个线程使用信号量进行同步。

每次内存分配按照相应的测试数据的要求进行操作。

每个测试数据单元描述一次内存分配操作，测试数据有程序随机自动产生，并把产生的测试数据保存在一个文件中。

模拟内存分配活动的线程可以从测试数据文件中读出要进行的内存操作。

每个内存操作包括以下内容：1）时间：操作等待时间，即等待相应时间后执行内存分配操作(要求随机产生)；2）块数：操作的内存页数(要求随机产生)；3）操作类型：可以是保留（reserve）、提交（commit）、释放（release）、回收（decommit）、加锁（lock）、解锁（unlock）；保留：在虚拟地址空间分配，不分配物理空间提交：在物理地址空间分配回收：释放物理空间，但保留虚拟空间释放：释放物理空间和虚拟空间加锁：常驻内存，即防止操作系统把对应的内存空间换出到外存可以将这些操作编号，存放于文件中。

4）大小：指块的大小；5）访问权限：共五种PAGE_READONLY、PAGE_READWRITE、PAGE_EXCUTE、PAGE_EXECUTE_READ 和PAGE_ EXECUTE_READWRITE。

可以将这些权限编号，存放于文件中。

运行结果显示要求：每次内存分配操作给出一组此次分配的相关信息，包括操作类型、权限类型、分配的起始地址和大小等；每次内存分配操作之后给出一组关于系统和内存的当前状态的信息。

2．实验要求●学习并理解请求分页存储管理方式；●学习了解虚拟存储技术的技术特点；●熟悉实验环境，掌握相关API的使用方法；●设计程序，实现以页为单位的虚拟内存分配方法；●不限制所使用的程序设计语言；●查阅有关资料；●提交实验报告。

操作系统的进程调度与内存管理策略在计算机系统中，操作系统扮演着至关重要的角色，负责管理和协调计算机中的各种资源。

其中，进程调度和内存管理是操作系统中两个关键的方面。

本文将探讨操作系统的进程调度和内存管理策略，以及它们对系统性能和效率的影响。

一、进程调度进程是操作系统中的执行实体，具有一定的程序、数据和执行状态。

在计算机系统中，可能有多个进程同时运行，操作系统需要合理地分配有限的CPU时间片给不同的进程，以确保系统的正常运行和资源利用的最大化。

1.1 先来先服务（FCFS）先来先服务是最简单的进程调度算法，按照进程到达的先后顺序进行调度。

当一个进程开始执行后，直到完成或者发生I/O请求才会释放CPU。

这种调度算法的优点是实现简单，公平性好，但容易产生"饥饿"现象，长作业会占据CPU时间，短作业需要等待时间较长。

1.2 短作业优先（SJF）短作业优先是一种基于作业执行时间的调度算法，优先选择估计执行时间最短的作业。

这种算法可以最大化CPU利用率，并且减少平均周转时间。

但是，由于无法准确估计作业的执行时间，可能会导致长作业等待时间过长。

1.3 时间片轮转（RR）时间片轮转算法将CPU时间分片，每个进程在一个时间片内执行完毕后，轮转到下一个进程执行。

这种调度算法能够保证每个进程都有机会获得CPU时间，避免了长作业等待时间过长的问题。

但是，如果时间片过长，会导致短作业等待时间增加；如果时间片过短，会导致更多的上下文切换开销。

二、内存管理策略内存管理是操作系统中的另一个重要方面，负责有效地分配和管理计算机系统中的内存资源。

主要有以下几种策略。

2.1 固定分区分配固定分区分配将系统内存分为若干固定大小的分区，每个分区只能装载一个进程。

这种策略简单直接，但是存在内存碎片问题，导致大量内存浪费。

2.2 动态分区分配动态分区分配将系统内存分为多个大小不同的动态分区，可以根据进程的实际需要进行分配。

实验二处理机管理（4学时）实验目的正确理解提高处理机的利用率及改善系统性能在很大程度上取决于处理机调度性能的好坏，在操作系统中调度的实质是一种资源分配，调度算法是指根据系统的资源分配策略规定的资源分配算法，对不同的系统和系统目标，应采用不的调度算法。

（或）在多道程序或多任务系统中，系统同时处于就绪状态的进程有若干个。

也就是说能运行的进程数远远大于处理机个数。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择一进程占用处理机。

通过本实验，加深对处理机调度的理解。

实验内容处理机管理是操作系统中非常重要的部分。

为深入理解进程管理部分的功能，设计几个调度算法，模拟实现处理机的调度。

编程模拟FCFS调度算法、SJ(P)F算法、高优先权调度算法、基于时间片轮转调度算法。

注：“基于时间片轮转调度算法模拟”为必作，其余选做。

实验准备及实验设备计算机，Tc2.0实验步骤正确理解各调度算法的基本思想；根据各调度算法定义PCB（模拟）的格式：FCFS算法和基于时间片轮转调度算法，可设PCB的格式为：高优先权调度算法可设PC为：在正确理解各调度算的基础上编写出相应的程序。

在所设计的调度程序中，针对不同算法应包含显示和打印语句，以便显示或打印程序运行的初值和运行结果：各PCB的初始状态，选中运行进程的名称、运行后各PCB状态以及每次调度时，就绪队列的进程排列顺序（针对不同算法有所不同）。

(源程序)实验结果（运行所编的模拟调度程序，所得结果略）FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。

SJ（P）F算法不利于长作业（进程），该算法未考虑作业的紧迫程序，因而不能保证紧迫性作业（进程）会被及时处理，并且由于作业（进程）的长短是用户所提供的估计执行时间而定的，致使该算法不一定能真正做到短作业优先调度。

高优先权（分动态和静态优先权）调度算法即照顾了短作业，又考虑了作业到达的紧迫性。

对于静态优先权法，系统开销小，但不够精确，可能出现优先权低的作业（进程）长期没有被调度的情况；对于动态优先权（高响应比优先）法，它既照顾了短作业，又考虑了作业的先后次序，不会使长作业长期得不到服务，但每要进行调度之前，都须做响应比的计算，会增加系统开销。

实验二：处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

设计一个按优先数调度算法实现处理器调度的程序。

[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志K2K1 K2 K3 K4 K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。