课程名称：
实验项目：
实验地点：
专业班级：
学生姓名：
指导教师：
操作系统B 操作系统实验 逸夫楼402、逸夫楼502教室 软件1415班
朱伟 学号： 2014005960 张俊花
2016年11月28日
实验一 几种操作系统的界面
一、目的和要求
（一）目的
本实验的目的是使学生熟悉1—2种操作系统的界面，在熟练使用机器的基础上，能了解各种操作命令和系统调用在系统中的大致工作过程。也就是通过操作系统的外部特征，逐步深入到操作系统的内部实质内容中去。
（二）要求
1. 能熟练的在1—2种操作系统的环境下工作，学会使用各种命令，熟悉系统提供的各种功能，主动而有效地使用计算机。
2. 熟悉系统实用程序的调用方法和各种系统调用模块的功能和作用
二、实验内容
在某种操作系统的环境下建立、修改、运行、打印源程序和结果，最后撤消一个完整的程序。 提示：可按下述步骤进行
1． 编写一个完整的源程序，通过编辑命令送入机器，建立源程序文件； 2． 编译该源文件，建立相应的目标文件；
3． 编译有错时，再用编辑命令修改源文件，消除全部词法和语法错误； 4． 连接目标文件，形成可执行文件； 5． 执行该文件，得到结果； 6． 打印输出源程序和运行结果； 7． 撤消本次实验中形成的所有文件。
三、实验步骤及程序流程图
1、按住Windows键+R输入notepad回车调出记事本。
2、编辑一个java程序选择另存为F：。
3、按住Windows键+R输入cmd回车。
4、进入Dos界面输入F：。
5、输入dir查看java文件，使用javac命令进行编辑
四、程序清单
class demo {
public static void main(String [] args) {
System.out.print(\软件1415班 朱伟 2014005960\ }
}
五、实验心得
这次实验是在win7操作系统下进行的，通过编译连接一个java小程序熟悉DOS命令的使用。实验中用到的DOS工具：
dir：列出当前控制台所在的路径下的所有文件以及文件夹。
javac：编译。
这次实验，通过查找一些常用的DOS命令，进一步熟悉了DOS命令的使用，了解了部分操作命令和系统调用在系统中的工作过程。
实验二 进程调度程序设计
一、目的和要求
（一） 目的
进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验可使学生加深对进程调度和各种调度算法的理解。
（二） 要求
1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB)表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占用CPU的时间以及进程的状态等，且可按照调度算法的不同而增删。
2． 调度程序应包含2—3种不同的调度算法，运行时可以任选一种，以利于各种方法的分析和比较。 3． 系统应能显示或打印各进程状态和参数的变化情况，便于观察。
二、示例
1． 题目 本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假定起始状态都是就绪状态W。
为了便于处理，程序中进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。
进程控制块结构如表2-1所示：
表2-1 PCB
进程标识符 链指针 优先数/轮转时间片数 占用CPU时间片数 进程所需时间片数 进程状态
进程控制块链结构如图2-1所示：
RUN HEAD TAIL
1 3 5 2 0 ┇ ? ┇ ┇ ┇ R W W W 图2-1 进程控制块链结构
其中：RUN—当前运行进程指针；
HEAD—进程就绪链链首指针；
TAIL—进程就绪链链尾指针。
2. 算法与框图 程序框图如图2-2所示。
开始 输入调度算法alog priority alog=priority/round robin? 生成并按优先数大小排列进程控制块链 链首进程投入运行 生成并按进入次序 排列进程控制块链 链首进程投入运行 round robin 时间片到，进程时间片 数减1，优先数减3 是 否 时间片到，进程时间片数 减1，占用CPU时间加1 进程时间片数为0？ 否 优先数大于链首进程? 占用处理机时间片到? 否 进程时间片数为0？ 是 撤消该进程 从链首取一个进程投入运行 否 进程队列空? 是 结束 否 运行进程退出，按优先数插入进程链 是 运行进程退出，排到进程链尾部 是 撤消该进程 从链首取一个进程投入运行 否 进程队列空? 是 结束 图2-2 进程调度框图
(1)优先数法。 进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。理由是该进程如果在一个时间片中完成不了，优先级应降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。 进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项
位置）。每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
三、实验代码：
#include
struct process /*PCB STRUCTURE*/ {
int id; int priority; int cputime; int alltime; char state; int next;
}prochain[furthest - 1]; int procnum; int rand(); int algo;
int run, head, tail, j; void print(); void insert(int q); void insert2(); void timesch(); void init(); void prisch();
int main() /*MAIN PROGRAM*/ {
agan: printf(\);
scanf(\, &algo); if (algo == 2) {
printf(\);
}
}
init(); prisch();
else { }
for (j = 1; j <= 40; j++) { }
printf(\);
for (j = 1; j <= 40; j++) { }
printf(\);
printf(\); getchar();
printf(\); printf(\); if (algo == 1) { } else { }
printf(\); goto agan;
printf(\); init(); timesch();
void print() /*PRINT THE RUNNING PROCESS,WAITING {
int k, p;
QUEUE AND PCB SEQUENCE LIST*/
for (k = 1; k <= 40; k++)
printf(\);
printf(\); printf(\);
printf(\, prochain[run].id); p = head; while (p != 0) { }
printf(\);
for (k = 1; k <= 40; k++)
printf(\); printf(\, p); p = prochain[p].next;
printf(\);
printf(\); for (k = 1; k printf(\, prochain[k].id); printf(\); printf(\); for (k = 1; k printf(\, prochain[k].priority); printf(\); printf(\); for (k = 1; k printf(\, prochain[k].cputime); printf(\); printf(\); for (k = 1; k printf(\, prochain[k].alltime); printf(\); printf(\); for (k = 1; k printf(\, prochain[k].state); } printf(\); printf(\); for (k = 1; k printf(\, prochain[k].next); printf(\); void insert(int q) /*INSERT A PROCESS*/ { } void insert2() /*PUT A PROCESS ONTO THE TAIL OF THE QUEUE*/ { prochain[tail].next = run; } void init() /*CREATE A WAITING QUEUE*/ { int i; head = 0; if (algo == 2) { for (i = 1; i prochain[run].next = 0; int p, s; p = head; s = prochain[head].next; while ((prochain[q].priority prochain[p].next = q; prochain[q].next = s; p = s; s = prochain[s].next; prochain[i].id = i; prochain[i].priority = (rand() + 11) % 41; prochain[i].cputime = 0; prochain[i].alltime = (rand() + 1) % 7; prochain[i].state = 'W'; prochain[i].next = 0; if ((prochain[i].priority run = head; prochain[run].state = 'R'; for (i = 1; i prochain[furthest].next = 0; prochain[i].id = i; prochain[i].priority = (rand() + 1) % 3 + 1; prochain[i].cputime = 0; prochain[i].alltime = (rand() + 1) % 7; prochain[i].state = 'W'; prochain[i].next = (i + 1) % (furthest + 1); } insert(prochain[i].id); else { } prochain[i].next = head; head = prochain[i].id; head = prochain[head].next; prochain[run].next = 0; } print(); void prisch() /*THE PROCESS WITH PRIO ALGORITHM*/ { while (run != 0) { prochain[run].cputime += 1; prochain[run].priority -= 3; prochain[run].alltime -= 1; if (prochain[run].alltime == 0) { prochain[run].state = 'F'; prochain[run].next = 0; if (head != 0) { } else { run = head; prochain[run].state = 'R'; head = prochain[head].next; prochain[0].id = prochain[run].id; run = 0; } else { if ((prochain[run].priority< prochain[head].priority) && (head != 0)) { prochain[run].state = 'W'; insert(run); run = head; prochain[run].state = 'R'; head = prochain[head].next; } } } } } print(); void timesch() /*THE PROCESS WITH RR ALRORITHM*/ { while (run != 0) { prochain[run].alltime -= 1; prochain[run].cputime += 1; if (prochain[run].alltime == 0) { } else { if ((prochain[run].cputime == prochain[run]. { prochain[run].state = 'W'; prochain[run].cputime = 0; priority) && (head != 0)) prochain[run].state = 'F'; prochain[run].next = 0; if (head != 0) { } else { } prochain[0].id = prochain[run].id; run = 0; run = head; prochain[run].state = 'R'; head = prochain[head].next; } } insert2(); run = head; prochain[run].state = 'R'; head = prochain[head].next; print(); 四、实验结果： （1） （2） 五、实验心得： 通过本次实验，加深了对进程调度和调度算法的理解。 对于简单轮转法，既将全部的进程按照进入的先后顺序排成一个就绪队列，设置每隔一段时间后将CPU分配给队列中新的队首进程，这样就可以保证就绪队列中的所有进程在确定的时间段内都能获得一个时间片的处理机时间。 而对于优先数法，本次试验中使用了动态优先数对进程进行排序，即就绪队列按优先数从大到小进行排列，而各进程的优先数随着进程的推进而改变，以达到获取更好的调度性能的目的。 简单轮转法有效的保证了队列中的所有进程都能分配到处理机，而优先数法则可防止一个长作业长期的垄断处理机。 实验三 存储管理程序设计 一、目的和要求 （一） 目的 存储管理的主要功能之一是合理地分配主存空间。请求页式管理是一种常用的虚拟存储管理技术。 本实验的目的是通过请求页式存储管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 （二） 要求 模拟页式虚拟存储管理中硬件的地址转换和缺页中断的处理过程，并用先进先出调度算法（FIFO）处理缺页中断。 二、提示 (1) 为了装入一个页面而必须调出一页时，如果被选中调出的页面在执行中没有修改过，则不必把该页重新写到磁盘上（因磁盘上已有副本）。因此，在页表中可以增加是否修改过的标志，当执行“存”指令、“写”指令时把对应页的修改标志置成“1”，表示该页修改过，否则为“0”，表示该页未修改过。页表格式如表3-1所示。 表3-1 页表格式 页 号 标 志 主存块号 修改标志 磁盘上的位置 (2) 设计一个地址转换程序来模拟硬件的地址转换和缺页中断处理过程。当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可用输出转换后的绝对地址来表示一条指令已完成。当访问的页不在主存时则输出“*该页页号”来表示硬件产生了一次缺页中断。模拟地址转换的程序流程如图3-1所示。 (3) 编制一个FIFO页面调度程序。FIFO页面调度算法总是先调出作业中最先进入主存的那一页，因此，可以用一个数组来构成页号队列。数组中每个元素是该作业已在主存的页面号，假定分配给作业的主存块数为m，且该作业开始的m页已装入主存，则数组可由m个元素组成： P[0]，P[1]，?，P[m-1] 它们的初值为 P[0]∶=0，P[1]∶=1，?，P[m-1]∶= m-1 用一指针k指示当要装入新页时应调出的页在数组的位置，k的初值为“0”。 三、实验报告内容要求 编程实现前述功能。 开始 取一条指令 取指令中访问的页号＝＞L 查页表 是 形成绝对地址 是 置L页修改标志”1” 输出绝对地址 是 取一条指令 否 模拟硬件 结束 地址转换 否(产生缺页中断) 页标志=1? 是”存”指令? 否 输出“﹡页号” 有后继指令? j∶= P[k] 模拟FIFO页面调度 是 输出“OUTj” 输出“IN L” j页的修改标志=1? 否 P[k]∶=L k∶=(k+1) mod m 修改页表 图3-1 地址转换和FIFO页面调度流程 当产生缺页中断后，操作系统总是选择P[k]所指出的页面调出，然后执行 P[k]∶=要装入的新页页号 k∶=（k+1）mod m 在实验中不必实际地启动磁盘执行调出一页和装入一页的工作，而用输出“OUT调出的页号”和“IN要装入的新页页号”来模拟一次调出和装入的过程。模拟程序的流程见图3-1。 (4) 假定主存的每块长度为1024个字节，现有一个共7页的作业，其副本已在磁盘上。系统为该作业分配了4块主存块，且该作业的第0页至第3页已经装入主存，其余3页尚未装入主存，该作业的页表见 表3-2所示。 表3-2 作业的页表 页号 0 1 2 3 4 5 6 标志 1 1 1 1 0 0 0 主存块号 5 8 9 1 修改标志 0 0 0 0 0 0 0 在磁盘上的位置 011 012 013 021 022 023 121 如果该作业依次执行的指令序列如表3-3所示。 表3-3 作业依次执行的指令序列 操作 + + × 存 取 - 页号 0 1 2 3 0 6 页内地址 070 050 015 021 056 040 操作 移位 + 存 取 + 存 页号 4 5 1 2 4 6 页内地址 053 023 037 078 001 084 依次执行上述的指令序列来调试你所设计的程序（仅模拟指令的执行，不必考虑指令序列中具体操作的执行） (5) 为了检查程序的正确性，可自行确定若干组指令序列，运行设计的程序，核对执行结果。 四、代码: #include int address;//地址 int page;//页号 int block;//块号 struct pageTable *next; }; typedef struct pageTable PAGETABLE; PAGETABLE *pt; const int first_memory = 1000;//内存首地址 int work[320];//作业 int index, offset;//index是作业的页号，offset为页内偏移地址 PAGETABLE*oldPtr;//minPtr指向驻留时间最久的页 int count1;//记数器，用于记录发生的缺页数 bool is_LRU = false;//是否是LRU算法 void init(); void insertPage(); void pushback_Page(PAGETABLE *, PAGETABLE *); void print(PAGETABLE *); void run(int); void find_FIFO(); void find_LRU(); void main(void) { int i = 0; while (1) { cout << \ << endl; cout << \先进先出算法（FIFO）\ << endl; cout << \最久未使用算法（LRU）\ << endl; cout << \程序结束\ << endl; cin >> i; if (i == 1) { } else if (i == 2) { cout << \ << endl; is_LRU = false; init();//构造页表和内存 } } } cout << \ << endl; is_LRU = true; init();//构造页表和内存 else if (i == 0) { } exit(1); void init() { for (int f = 0; f<53; f++)//作业运行 { for (int k = 0; k<320; k++)//初始化作业 { } work[k] = k; oldPtr = pt->next;//初始化最久的页面 cout << \页表初始状态为：\ << endl; print(pt); double rate; int count = 0;//记数器初值为0 srand(time(NULL)); pt = new PAGETABLE; pt->next = NULL; for (int i = 0; i<4; i++) { } insertPage(); } int m, m1, m2; m = rand() % 320; if (m == 319) m = 318; run(m); print(pt); run(m + 1); print(pt); } if (m == 0) m1 = 0; else m1 = rand() % m; run(m1); print(pt); run(m1 + 1); print(pt); m2 = rand() % (320 - m) + m - 1; if (m2<0) m2 = 318; if (m2 == 319) m2 = 318; run(m2); print(pt); run(m2 + 1); print(pt); rate = (double)count / 318 * 100; cout << \缺页率为：\ << rate << \ << endl; /* 构建页表*/ void insertPage() { } PAGETABLE *newPage; static int id = 99; static int blockId = -1; id++; blockId++; if (blockId == 4) blockId = 0; newPage = (PAGETABLE *)malloc(sizeof(PAGETABLE)); if (newPage != NULL) { } else cout << \没有内存足够的空间为页表分配！\ << endl; newPage->address = id; newPage->page = -1; newPage->block = blockId; newPage->next = NULL; pushback_Page(pt, newPage); void pushback_Page(PAGETABLE *queue, PAGETABLE *item) { } void print(PAGETABLE *ptr) { PAGETABLE *temp; PAGETABLE *previous, *current; previous = queue; current = queue->next; while (current != NULL) { } previous->next = item; previous = current; current = current->next; } temp = ptr->next; cout << \页号 \ << \块号 \ << endl; while (temp != NULL) { } cout << \ << temp->page << \ << temp->block << endl; temp = temp->next; void run(int num) { int universal; PAGETABLE *previous, *current; index = work[num] / 10;//程序所在的页号 offset = work[num] % 10;//页内的位移量 previous = pt; current = previous->next; while (current != NULL && current->page != index) { } if (current == NULL) { cout << \作业\ << num << \没有在内存，发生缺页中断\ << endl; count1++; if (is_LRU == false)//FIFO算法 { } else//LRU算法 { } find_LRU(); find_FIFO(); previous = current; current = current->next; } } else { } if (is_LRU == false)//FIFO算法 { } else { } if (current->next == NULL) { } else { } PAGETABLE *temp, *ptr; temp = current; previous->next = current->next; ptr = pt->next; while (ptr->next != NULL) { } ptr->next = temp; temp->next = NULL; universal = first_memory + (temp->block) * 10 + offset; cout << \作业\ << num << \所在内存的物理地址为 \ << universal << endl; ptr = ptr->next; universal = first_memory + (current->block) * 10 + offset; cout << \作业\ << num << \所在内存的物理地址为 \ << universal << endl; universal = first_memory + (current->block) * 10 + offset; cout << \作业\ << num << \所在内存的物理地址为 \ << universal << endl; 五、结果: （1）先进先出算法FIFO： （2）最久未使用算法LRU 五、实验心得 本次试验的目的是通过请求页式存储管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。实验中主要使用了FIFO算法，即总是先淘汰最先进入内存的页面（驻留最久的页面），实现时只需要把一个进程也调入内存的页面按先后次序链接成一个队列，并设置一个指针，总是指向最老的页面。 FIFO的主要的缺点是没有考虑到有的页面会经常被访问，因此并没有办法保证这种页面能够保留在内存中，可能使得利用率较低。 通过本次试验加深了对相应算法的理解，巩固了相关的知识和使用的方法。
太原理工大学操作系统实验报告2016
