操作系统课程设计（无代码）

实验1：作业调度

1.1实验目的

1、 对作业调度的相关内容作进一步的理解。
2、 明白作业调度的主要任务。
3、 通过编程掌握作业调度的主要算法。

1.2实验内容

1、 假设系统中可同时运行两道作业，给出每道作业的到达时间和运行时间，如下表所示：

2、 分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、 计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣
说明：
响应比=等待时间/运行时间+1
周转时间=完成时间-到达时间
带权周转时间=周转时间/运行时间

1.3实验思路

1. FIFO：按照到达时间排序，取两个double变量，作时间标记，表示当前时间，然后遍历works；
      当t1>t2时：
        t2作业先完成，让给下一个作业，注意：t2与下一个作业的到达时间比较；
      当t1<=t2时：
        t1作业先完成，让给下一个作业，注意：t1与下一个作业的到达时间比较。

2. SJF：按照作业运行时间排序，取两个double量同上作用；
      当t1>t2时：
        t2作业先完成，取下一个作业，其运行时间是未运行作业中最短的，但是，存在一个问
        题：该作业运行时间最短，但没到达，存在一个到达而运行时间更长的作业，此时，需要
        运行第二个作业；
        找第二个作业的方法：按run排序
          【1】 如果存在到达的作业：第一个找到的作业即是
          【2】 如果不存在到达的作业：后续作业中第一个到达的
        然后执行该作业，该作业pop，并push到另一个容器，作最后输出
      当t1<=t2时：基本同上

3. HRF：先按到达时间排序
      当t1>t2时：
        若t2为0，表示仅执行过一次作业且是t1负责，后续作业第一个到达的就是响应比最高的，
        为1；
        若t2不为0，（如无作业到达，t2增加到直到后续第一个作业到达），在剩余作业中找出已
        到达且响应比最高的作业，执行并pop，push到另一个容器作最后输出
      当t1<=t2，同上

1.4实验结果

实验2：磁盘调度

2.1实验目的

1、 对磁盘调度的相关知识作进一步的了解，明确磁盘调度的原理。
2、 加深理解磁盘调度的主要任务。
3、 通过编程，掌握磁盘调度的主要算法。

2.2实验内容

1、 对于如下给定的一组磁盘访问进行调度：

2、 要求分别采用先来先服务、最短寻道优先以及电梯调度算法进行调度。
3、 要求给出每种算法中磁盘访问的顺序，计算出平均移动道数。
4、 假定当前读写头在90号，电梯调度算法向磁道号增加的方向移动。

2.3 设计思路

1. FCFS：按照读取时的顺序服务

2. SSTF：从磁头90开始，找到距离最近的一个，访问，重复以上过程直到访问结束；
   说明：遍历n次，n是访问次数，每次挑出距离当前位置最近且未访问的磁道，已访问的磁道置-1

3. SCAN：电梯调度算法，按照类快排思想，把访问的磁道号按照磁头90分为两个部分v1和v2，v1存储磁头左侧，v2存储磁头右侧，v1和v2排序，然后电梯式访问。
   说明：磁头90，方向向增长方向移动，即先访问v2，直到边界，反转，访问v1，结束；设置的磁道号范围[0,199]

2.4实验结果

实验3：熟悉linux文件系统调用

3.1实验目的

1、 掌握 linux 提供的文件系统调用的使用方法；
2、 熟悉文件系统的系统调用用户接口；
3、 了解操作系统文件系统的工作原理和工作方式。

3.2实验内容

使用文件系统调用编写一个文件工具filetool使具有以下功能：
1.创建新文件
2.写文件
3.读文件
4.修改文件权限
5.查看当前文件权限
0.退出
提示用户输入功能号，并根据用户输入的功能选择相应的功能。
文件按可变记录文件组织，具体记录内容自行设计。

3.3设计思路

1. 功能1：创建新文件
   1） 输入文件名
   2） 创建文件：系统调用creat，参数（文件名 , 0755），0755是默认文件权限
   3） 提示创建成功or失败
2. 功能2：写文件
   1） 输入文件名
   2） 是否使用vim进行写
   3） 是：使用system调用vi进行写
   4） 否：
      i. 输入文本
      ii. 打开文件：系统调用open，参数（文件名 , O_WRONLY|O_CREAT|O_APPEND）
      参数（文件名 , O_WRONLY|O_CREAT|O_TRUNC）
      iii. 写入文件：系统调用write，参数（文件描述符 , buf , size）
      iv. 关闭文件描述符
3. 功能3：读文件
   1） 输入文件名
   2） 是否使用cat查看
   3） 是：使用system调用cat进行读
   4） 否：
      i. 打开文件：系统调用open，参数（文件名 , O_RDONLY|O_CREAT）
      ii. 读取文件内容：系统调用read，参数（文件描述符 , buf , size）
      iii. 输出后关闭文件描述符
4. 功能4：修改文件权限
   1） 输入文件名
   2） 查看文件是否存在：系统调用access，参数（文件名 , F_OK）
   3） 显示当前文件权限：系统调用execl，参数（”/bin/ls” , ”ls” , ”-l” , 文件名 , NULL）
   4） 输入新的权限，ugo=：三个整数，八进制意义
   5） 将ugo转为mode_t，八进制
   6） 修改权限：系统调用chmod，参数（文件名 , mode_t）
5. 功能5：查看当前文件权限
   1） 输入文件名
   2） 调用fork，分裂子进程，调用execl + ls 查看文件权限，父进程阻塞等待子进程结束

3.4实验结果

实验4：进程管理

4.1实验目的

1、 理解进程的概念，明确进程和程序的区别。
2、 理解并发执行的实质。
3、 掌握进程的同步、撤销等进程控制方法。

4.2实验内容

1、 父进程使用系统调用pipe()建立一个管道，然后使用系统调用fork()创建两个子进程：子进程1和子进程2
2、 子进程1每隔1秒通过管道向子进程2发送数据：I send message x times.（x初值为1，以后发送一次后做加一操作），子进程2从管道读出信息，并显示在屏幕上
3、 父进程用系统调用signal()来捕捉来自键盘的中断信号SIGINT（即按Ctrl+C键,）；当捕捉到中断信号后，父进程用系统调用kill()向两个子进程发出信号，子进程捕捉到信号后分别输出如下信息后终止： Child Process 1 is killed by Parent! 和 Child Process 2 is killed by Parent!
4、 父进程等待两个子进程终止后，释放管道并输出如下的信息后终止 Parent Process is Killed!

4.3设计思路

1、 创建管道：pipe
2、 设置信号；SIGINT
3、 创建两个子进程1、2
4、 子进程1：
   1） 屏蔽SIGINT信号
   2） 关闭管道-读
   3） 设置信号SIGABRT：用于接收父进程的通知
   4） 开始循环向管道写数据“I send message x times”，x=1++
5、 子进程2：
   1） 屏蔽SIGINT信号
   2） 关闭管道-写
   3） 设置信号SIGABRT：接收父进程通知
   4） 从管道循环读取数据，输出
6、 父进程：
   1） 阻塞等待两个子进程结束
   2） 输出“Parent Process is killed”
   3） 关闭管道

7、 说明：
   1） 信号SIGINT：signal(SIGINT,函数1)
   2） 信号SIGABRT：signal(SIGABRT,函数2)
   3） 屏蔽信号：signal(SIGINT,SIG_IGN)
   4） 函数1：通过kill向两个子进程发送信号SIGABRT
   5） 函数2：关闭管道，若是子进程1则输出“Child Process 1 is killed by Parent”，然后结束进程；若是子进程
       2则输出“** 2 **”，结束进程

4.4实验结果

实验五

5.1实验目的

1、 了解虚拟存储技术的特点
2、 掌握请求分页系统的页面置换算法

5.2实验内容

1、 通过如下方法产生一指令序列，共320条指令

1. 在[1，32k-2]的指令地址之间随机选取一起点,访问 M；
2. 顺序访问M+1；
3. 在[0，M-1]中随机选取M1，访问 M1；
4. 顺序访问M1+1；
5. 在[M1+2，32k-2]中随机选取M2，访问 M2；
6. 顺序访问M2+1；
7. 重复 A—F，直到执行 320 次指令。

2、 指令序列变换成页地址流，设：

1. 页面大小为 1K
2. 分配给用户的内存页个数为 4 页到 32 页,步长为1页；
3. 用户虚存容量为 32K。

3、 计算并输出下述各种算法在不同内存页块下的命中率。

1. 先进先出（FIFO）页面置换算法
2. 最近最久未使用（LRU）页面置换算法
3. 最佳（Optimal）页面置换算法

5.3设计思路

1、 FIFO

1. 定义一个队列q 和 bool数组flag
2. 遍历320条命令
   i. 转换为页号p
   ii. 若flag[p]是true，页号p存在于内存块中，命中数+1
   iii. 若flag[p]是false，页号p不存在于内存块中
      a) flag[p]置true，进入内存块
      b) 如果队列q大小等于内存块大小，出队首页号，并置false
      c) 页号p入队尾
3. 释放内存并输出命中率

2、 LRU

1. 定义一个队列q和队列大小n（不同页，同页计1），int数组flag（表示队列中，页号i的个数flag[i]）
2. 遍历320条命令
   [1] 转换为页号p
   [2] 如果flag[p]>0，命中次数+1，队列中页号p出现次数+1（flag[p]++），页号p入队
   [3] 如果flag[p]=0，页号p入队，flag[p]=1
      a) 如果n==内存块，pop队首front直到flag[front]==1，即flag[front]!=1的全部pop，且
       flag[front]–，第一个flag[front]==1的也pop，flag[front]=0
      b) 如果n<内存块，++n
3. 释放内存并输出命中率

3、 OPT

1. 定义bool数组，标记存在于内存块的页号
2. 定义map<int,vector >，实现页号与下标映射，即命令i的页号为p，则i入vector
3. 定义n，内存块中页号个数
4. 遍历320条命令：i
   [1] 命令i转换为页号p
   [2] 如果flag[p]=true，即页号p在内存中，命中次数+1
   [3] 如果flag[p]=false，即页号p不在内存中
      a) 如果n<内存块，页号p入内存，即++n，flag[p]=true
      b) 如果n==内存块，对于存在于内存中的所有页号，遍历其映射的vector，找出下一次出现
       的下标j
        case 1: 如果存在 内存中某一个页号 不再出现，该页出内存，置false，p入内存，置true
        case 2: 如果不存在上述条件，找出最大的j，即内存中某页号，下一次出现距离最远，出
               内存，置false，p入内存，置true
5. 释放内存并输出命中率

5.4实验结果

memory=4 , 32

实验六

6.1实验目的

1、 理解管道机制、消息缓冲队列、共享存储区机制进行进程间的通信；
2、 理解通信机制

6.2实验内容

编写一主程序可以由用户选择如下三种进程通信方式：
1、 使用管道来实现父子进程之间的进程通信

1. 子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent”。
2. 父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上
3. 终止。终止。

2、 使用消息缓冲队列来实现 client 进程和 server 进程之间的通信

1. server 进程先建立一个关键字为 SVKEY（如 75）的消息队列，然后等待接收类型为 REQ（例如 1）的消息；在收到请求消息后，它便显示字符串“serving for client”和接收到的 client 进程的进程标识数，表示正在为 client 进程服务；然后再向 client 进程发送应答消息，该消息的类型是 client 进程的进程标识数，而正文则是 server 进程自己的标识ID。
2. client 进程则向消息队列发送类型为 REQ 的消息（消息的正文为自己的进程标识 ID） 以取得 sever 进程的服务，并等待 server 进程发来的应答；然后显示字符串“receive reply from”和接收到的 server 进程的标识 ID。client 进程则向消息队列发送类型为 REQ 的消息（消息的正文为自己的进程标识 ID） 以取得 sever 进程的服务，并等待 server 进程发来的应答；然后显示字符串“receive reply from”和接收到的 server 进程的标识 ID。

3、 使用共享存储区来实现两个进程之间的进程通信

1. 进程 A 创建一个长度为 512 字节的共享内存，并显示写入该共享内存的数据；
2. 进程 B 将共享内存附加到自己的地址空间，并向共享内存中写入数据。进程 B 将共享内存附加到自己的地址空间，并向共享内存中写入数据。

6.3设计思路

1、管道通信：

1. 创建管道
2. 子进程写
   [1] 关闭管道-读
   [2] 调用write写入数据
   [3] 退出
3. 父进程读
   [1] 关闭管道-写
   [2] 调用read读取数据
   [3] 输出数据
   [4] 阻塞等待子进程退出
4. 关闭管道

2、 消息队列通信

1. 构造消息结构体：long 类型 和 char[] 数据
2. 创建子进程创建子进程
   [1] 调用msgget创建或取消息队列，返回id
   [2] 消息类型赋1，写入数据，调用msgsnd发送消息
   [3] 调用msgrcv接收消息，类型：子进程进程ID
   [4] 输出数据
   [5] 退出
3. 父进程
   [1] 调用msgget创建或取消息队列，返回id
   [2] 调用msgrcv接收消息，类型:1
   [3] 输出数据
   [4] 消息类型：子进程进程ID
   [5] 写入数据，发送消息
   [6] 阻塞等待子进程退出

3、 共享内存通信

1. 创建子进程
   [1] 忽略SIGUSR1信号
   [2] 调用shmget，创建或取共享内存
   [3] 调用shmat关联一个char* buf
   [4] 写入数据
   [5] 调用shmdt分离该区域
   [6] 发送信号SIGUSR1给父进程，通知输入完成，等待你接收，退出
2. 绑定信号SIGUSR1，函数1
3. while(b)阻塞，直到调用函数1将b=false
4. 调用shmid取内存
5. 调用shmat关联一个char* buf
6. 输出数据
7. 阻塞等待子进程退出
8. 调用shmctl删除共享内存

6.4实验结果