操作系统概论作业

第1章 Shell命令操作实践作业
(1)在当前登录用户的主目录下创建子目录mysub，进入mysub目录，。

cd
mkdir mysub
cd mysub
(2)显示当前目录路径。

pwd
(3)显示用户名
echo $USER 显示用户主目录
echo $HOME
(4)将用户主目录添加到可执行文件搜索路径
export PATH=$PATH:$HOME
(5)显示添加后的可执行文件搜索路径
echo $PATH
ls -l .{ba,pr}* > my1
ps aux | grep tty > my2
(8)将my1和my2串联成一个新文件my3
cat my1 my2 > my3
(9)将当前目录下的所有文件压缩归档到myf.tar.gz文件中
tar -zcvf ~/myf.tar.gz ./
(10)将my3移动到上级目录中
sudo mv my3 ../
(11)删除文件my1和my2
rm –f my1 my1(直接删除)
rm –i my1 my2(删除前确认)
(12)启动vi文本编辑程序
vi
(13)在vi中输入(3) ~ (11)步的操作命令，并将其存入文件mysh
i/a
echo $USER
echo $HOME
export PATH=$PATH:$HOME
echo $PATH
ls -l .{ba,pr}* > my1
ps aux | grep tty > my2
cat my1 my2 > my3
tar zcvf ~/myf.tar.gz ./
sudo mv my3 ../
rm –f my1 my1
rm –i my1 my2
:w mysh
(14)将vi放入后台运行
ctrl+z
bg %1
(15)将文件mysh访问权限改为文件主可执行
chmod u+x mysh
(16)将文件mysh复制到上级目录中
cp mysh ../
(17)令vi返回前台，从中追加睡眠1分钟和返回前台的命令，从vi保存退出
fg %1
sleep 60
fg
:wq
(18)以后台运行方式启动mysh
./mysh &
(19)找到执行睡眠命令的的进程号
ps -aux | grep sleep
(20)用发送信号命令向睡眠命令进程号发送终止信号，让mysh停止执行。

kill -15 xxxx
第2章与处理器管理有关的系统功能调用实践作业
参照“强化实践能力培养课程内容”中“进程创建和执行的实践能力培养考核选例”和“线程的创建及线程间管道通信实践能力培养考核选例”程序，编写一个能建立两个子进程的程序(父进程)，让这三个进程并发执行完成以下二元函数的计算：
其中由父进程完成：f(x,y) = f(x) + f(y)
由子进程1 完成阶乘计算： f(x) = f(x-1) * x (x>1)
f(x)=1 (x=1)
由子进程2完成非波纳奇序列： f(y) = f(y-1) + f(y-2) (y>2)
f(y)=1 (y=1,2)
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
long func_jc(int x)
{
long rtn;
if (x < 1)
{
puts("func_jc argv ERR!");
exit(EXIT_FAILURE);
}
else if (x == 1)
{
rtn = 1;
}
else
{
rtn = func_jc(x-1) * x;
}
return(rtn);
}
long func_xl(int y)
{
long rtn;
if (y < 1)
{
puts("func_xl argv ERR!");
exit(EXIT_FAILURE);
}
else if (y == 1 || y == 2)
{
rtn = 1;
}
else
{
rtn = func_xl(y-1) + func_xl(y-2);
}
return(rtn);
}
int main(int argc,char *argv[])
{
pid_t pid1,pid2;
long re1,re2;
int x,y,status;
int pipefd1[2],pipefd2[2];
if (argc != 3)
{
puts("ERR, need 2 int args");
exit(1);
}
sscanf(argv[1],"%d",&x);
sscanf(argv[2],"%d",&y);
if(pipe(pipefd1) < 0)
{
perror("pipefd1 not create");
exit(1);
}
pid1=fork();
switch (pid1)
{
case -1:
puts( "Process 1 Create Failed!");
exit(1);
case 0:
//printf( "pid1,x=%d\n",x);
re1=func_jc(x);
write(pipefd1[1],&re1,sizeof(int));
close(pipefd1[0]);
close(pipefd1[1]);
printf( "in pid1,re1=%ld\n",re1);
break;
default:
if(pipe(pipefd2) < 0){
perror("pipefd2 not create");
exit(1);
}
pid2=fork();
switch(pid2){
case -1:
puts( "Process 2 Create Failed!");
exit(1);
case 0:
//printf( "pid2,y=%d\n",y );
re2=func_xl(y);
write(pipefd2[1],&re2,sizeof(int));
close(pipefd2[0]);
close(pipefd2[1]);
printf( "in pid2,re2=%ld\n",re2);
break;
default:
close(pipefd1[1]);
close(pipefd2[1]);
//waitpid(pid1,&status,0);
//waitpid(pid2,&status,0);
waitpid(-1,&status,0);
read(pipefd1[0],&re1,sizeof(int));
read(pipefd2[0],&re2,sizeof(int));
close(pipefd1[0]);
close(pipefd2[0]);
//printf("main,x=%d,y=%d,stutus=%d\n",x,y,status); printf("in main, re1 + re2 = %ld\n",re1 + re2);
//break;
}
//break;
}
return 0;
}
第3章与存储管理有关的操作系统算法实践作业
参照“强化实践能力培养课程内容”中“内存页面置换算法实践能力培养考核选例”程序，
编写一个能演示LRU内存页面置换算法的程序，它可根据给定的一组页面引用序列号和实存
页数，显示LRU置换页的过程，能统计和报告LRU置换算法情况下依次淘汰的页号、缺页次
数（页错误数）和缺页率。

void random()
{
cout<<"-----------------随机-----------------"<<endl;
init();
int *save=new int[page_size];
int count=0;
cout<<"随机替换算法:"<<endl;
int lackTime=0;
int replace=0;
int is_full=0;
int page=0;
do
{
if(page_table[page_array[page]].flag ==1) {
cout<<page_array[page]<<" is in memory"<<endl;
page++;
if(page==page_size)break;
else continue;}
else{
lackTime++;
cout<<page_array[page]<<"is not in memory!"<<endl;
memory[is_full]=page_array[page];
page_table[page_array[page]].flag=1;
page_table[page_array[page]].memory_num=is_full;
is_full++;
page++;if(page==page_size)break;}
}while(is_full!=memory_size);
for( int i=page;i<page_size;i++)
{
if(page_table[page_array[i]].flag ==1){
cout<<page_array[i]<<" is in memory"<<endl;
continue;}
else{
lackTime++;
replace=rand()%memory_size;
for(int j=0;j<10;j++)
{
if( page_table[j].memory_num==replace)
{ cout<<page_array[i]<<"is not in memory!take place of page
"<<j<<endl;
save[count++]=j;
page_table[j].memory_num=-1;
page_table[j].flag=0;
break; }
}
memory[replace]=page_array[i];
page_table[page_array[i]].flag=1;
page_table[page_array[i]].memory_num=replace;
}
}
cout<<"缺页次数："<<lackTime<<endl;
cout<<"缺页率： "<<double(lackTime)/page_size*100<<"%"<<endl;
cout<<"淘汰页号的序列为：";
for(int i=0;i<count;i++) cout<<save[i]<<"->";
cout<<"结束"<<endl;
cout<<"--------------------------------------"<<endl;
}
LRU淘汰算法：
void LRU()
{
cout<<"-----------------LRU------------------"<<endl;
init();
int *change_page=new int[page_size];
int *weight=new int [memory_size];
int i;
for(i=0;i<memory_size;i++)
memory[i]=-1;
for(i=0;i<page_size;i++)
change_page[i]=0;
int lackTime=0;int k=0,l=0;
bool in=0;
int max=0;int q;
for(q=0;q<memory_size;q++)
cout<<memory[q]<<" ";
cout<<endl;
for(i=0;i<page_size;i++)
{
in=0;
for(q=0;q<memory_size;q++)
{
if (page_array[i]==memory[q])
｛in=1;break;｝
}
}
if(in==0 && memory[memory_size-1]!=-1)
{
lackTime++;
for(q=0;q<memory_size;q++)
weight[q]=0;
for(q=0;q<memory_size;q++)
{
for(int p=i-1;p>=0;p--)
{ weight[q]++;
if(memory[q]==page_array[p])break;}
}
max=0;
for(q=0;q<memory_size;q++)
{ if(weight[q]>max) max=weight[q];}
for(q=0;q<memory_size;q++)
{if (max==weight[q]) break;}
change_page[k++]=memory[q];
memory[q]=page_array[i];
}
if(in==0 && memory[memory_size-1]==-1){
lackTime++;
memory[l++]=page_array[i];
}
for(int q=0;q<memory_size;q++){
cout<<memory[q]<<" ";
cout<<endl;}
cout<<"缺页次数："<<lackTime<<endl;
cout<<"缺页率："<<double(lackTime)/page_size*100<<"%"<<endl;
cout<<"淘汰页号：";
for(int m=0;m<k;m++)
cout<<change_page[m]<<"->";
cout<<"结束"<<endl;
cout<<"-----------------LRU------------------"<<endl;
}
main()函数
int main()
{ int select1; int select2;
char choice;
cout<<"输入给定的页面数："<<endl;
cin>>page_size;
cout<<"输入给作业分配内存的物理块数"<<endl;
cin>>memory_size;
page_array=new int[page_size];
memory=new int[memory_size];
loop: cout<<"0.用户输入请求序列 1.随机生成请求序列"<<endl;
cin>>select1;
if(select1==1)
{ cout<<"随机生成页面请求序列（0-10）"<<endl;
int temp1;
for(int i=0;i<page_size;i++)
{ temp1=rand()%10;
cout<<temp1<<" ";
page_array[i]=temp1;}
cout<<endl;
}
else if(select1==0)
{ int temp2;
cout<<"输入"<<page_size<<"个请求页面号（0-10）"<<endl;
for(int i=0;i<page_size;i++)
{ cin>>temp2;
page_array[i]=temp2;}
}
else exit(0);
cout<<"请选择使用那种替换算法：0、退出 1、LRU 2、随机
"<<endl;
cin>>select2;
if(select2==1) LRU();
else if(select2==2) random();
else exit(0);
cout<<"是否继续？（Y/y or N/n）";
cin>>choice;
if(choice=='Y' || choice=='y') goto loop;
else exit(0);
delete []page_array;
delete []memory;
return 0;
}
测试结果
测试用例
LRU淘汰算法：
输入的页面号序列为：4 2 1 2 3 5 4 3 1 2，给定内存物理块数为3。

运行结果及分析
结果分析，如下表
LRU淘汰算法的运行结果如下：
结果分析，如下表：
第4章与文件管理有关的系统功能调用实践作业
参照“强化实践能力培养课程内容”中“文件操作实践能力培养考核选例”程序，请构造一个能管理文本文件的学生成绩表的简单数据库管理系统。

设文本文件的学生成绩表中每条学生成绩记录有3个字段构成：学号20个字节，姓名20个字节，成绩10个字节，字段间用空格分割对齐。

简单数据库管理系统具有基本的功能有：
追加一条记录，（仅允许文件主）
按学号读出一条记录，
按学号升序列出所有记录.
（提示：可建立一个学生成绩表文件和一个以学号为主键的索引文件。

）
/****************************************************************************** * File : managedemo.cpp
* Desc : 构造一个能管理文本文件的学生成绩表的简单数据库管理系统。

设文本文件的
* 学生成绩表中每条学生成绩记录有3个字段构成：学号20个字节，姓名20个字节，* 成绩10个字节，字段间用空格分割对齐。

简单数据库管理系统具有基本的功能有：*
追加一条记录，（仅允许文件主）
*
按学号读出一条记录，
*
按学号升序列出所有记录.
*
（提示：可建立一个学生成绩表文件和一个以学号为主键的索引文件。

）
******************************************************************************* /
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <vector>
#include <list>
#include <iterator>
#include <algorithm>
#define STAR "*****************************"
#define DBFILE "stu_record_db.txt" //数据文件名称
using namespace std;
class CWindow //界面类
{
public:
CWindow(){}
void display(); //显示界面
int get_input(); //获取输入
~CWindow(){}
};
void CWindow::display()
{
cout<<STAR<<endl;
cout<<"1-Append a new student-record"<<endl;
cout<<"2-Search a student-record"<<endl;
cout<<"3-Display all student-records"<<endl;
cout<<"4-Quit"<<endl;
cout<<STAR<<endl;
cout<<endl<<"Input the number front of your choice: ";
}
int CWindow::get_input()
{
string choice_str;
stringstream tran_stream;
int choice_num;
cin>>choice_str;
if(choice_str.length() > 1 || (choice_str[0] < '1' || choice_str[0] > '4')) //检查选项输入{
// cout<<"Error: Choice Error!"<<endl;
return -1;
}
else
{
tran_stream<<choice_str;
tran_stream>>choice_num;
return choice_num;
}
}
class CSturecord //学生信息类
{
public:
CSturecord(string stunum, string stuname = "\0", string stuscor = "\0"); //构造学生记录
void display_record(); //显示学生记录的信息
long get_number(); //获取学生学号信息bool operator == (const CSturecord& student)const; //重载== 用于search bool operator < (const CSturecord& student)const; //重载< 用于哈希~CSturecord(){}
string number;
string name;
string score;
long longintnum;
};
CSturecord::CSturecord(string stunum, string stuname, string stuscor)
{
number = stunum;
name = stuname;
score = stuscor;
get_number();
}
void CSturecord::display_record()
{
cout<<number<<" "<<name<<" "<<score<<" "<<endl;
}
long CSturecord::get_number()
{
stringstream stream;
stream<<this->number;
stream>>longintnum;
return longintnum;
}
bool CSturecord::operator == (const CSturecord& student)const
{
return student.number == number;
}
bool CSturecord::operator < (const CSturecord& student)const
{
return longintnum < student.longintnum;
}
class CSystem //程序数据库算法核心
{
public:
bool read_record(); //从文件中读取学生记录
bool append_rec(); //追加学生记录
bool search_rec(); //按学号显示学生信息
void sturec_sort(bool show = true); //排序
bool write_record(); //将记录写入文件
~CSystem(){}
private:
vector<CSturecord> sturec_vec;
static char filename[];
};
char CSystem::filename[] = DBFILE;
bool CSystem::read_record()
{
string str;
string number;
string name;
string score;
int i = 0;
vector<string> vstr;
ofstream outf(filename, ios::app); //若文件不存在，则新建
vector<string>::iterator viter = vstr.begin();
if(!outf)
{
cout<<filename<<" opened error!"<<endl;
return false;
}
outf.close();
ifstream inf(filename);
if(inf.fail())
{
cout<<filename<<" opened error!"<<endl;
return false;
}
while(inf>>number)
{
inf>>name;
inf>>score;
CSturecord stutemp(number, name, score);
sturec_vec.push_back(stutemp);
}
inf.close();
return true;
}
bool CSystem::append_rec()
{
string number, name, score;
cout<<"Please input the new student-record(number name score):"<<endl;
cin>>number>>name>>score;
CSturecord stutemp(number, name, score);
sturec_vec.push_back(stutemp);
cout<<"Saved the student-record : ";
sturec_vec.rbegin()->display_record();
return true;
}
bool CSystem::search_rec()
{
vector<CSturecord>::iterator result_iter;
vector<CSturecord>::iterator void_iter;
string search_number;
cout<<"Please input the student number you searched: ";
cin>>search_number;
CSturecord stutemp(search_number);
result_iter = lower_bound(sturec_vec.begin(), sturec_vec.end(), stutemp);
void_iter = sturec_vec.end() - 1;
if(result_iter == sturec_vec.end() || stutemp.longintnum != result_iter->longintnum) {
cout<<"No this student-record!"<<endl;
return false;
}
else
{
cout<<"The student-record is :";
result_iter->display_record();
return true;
}
}
void CSystem::sturec_sort(bool show)
{
list<CSturecord> stulist(sturec_vec.begin(), sturec_vec.end());
stulist.sort();
vector<CSturecord> vectemp(stulist.begin(), stulist.end());
sturec_vec = vectemp;
vector<CSturecord>::iterator veciter = sturec_vec.begin();
if(show){
for(; veciter != sturec_vec.end(); veciter++)
{
veciter->display_record();
}
}
}
bool CSystem::write_record()
{
ofstream outf(filename);
if(!outf)
{
cout<<filename<<" opened error"<<endl;
return false;
}
sturec_sort(false);
vector<CSturecord>::iterator veciter = sturec_vec.begin();
for(; veciter != sturec_vec.end(); veciter++)
{
outf<<veciter->number<<" ";
outf<<veciter->name<<" ";
outf<<veciter->score<<endl;
}
outf.close();
return true;
}
class CManage
{
public:
CManage();
~CManage(){}
void pro_start();
private:
CSystem* system;
};
CManage::CManage()
{
system = new CSystem;
system->read_record();
}
void CManage::pro_start()
{
int choice_num;
CWindow gui_wind;
do{
do{
gui_wind.display();
choice_num = gui_wind.get_input();
if(choice_num < 0)
{
cout<<"Error:Input error!"<<endl;
cout<<"Please input again: ";
}
else
{
break;
}
}while(1);
switch(choice_num)
{
case 1:
system->append_rec();
break;
case 2:
system->search_rec();
break;
case 3:
system->sturec_sort();
break;
case 4:
system->write_record();
delete system;
exit(0);
break;
}
}while(1);
}
int main(void)
{
CManage manage;
manage.pro_start();
return 0; }
第5章与设备管理有关的操作系统算法实践作业
参照“强化实践能力培养课程内容”中“磁盘移臂调度算法实践能力培养考核选例”程序编写一个能演示“最短寻找时间优先算法Sstf”的程序。

该程序能分析出“最短寻找时间优先算法”在响应任意给定的一组磁盘请求序列时磁头移动的过程，即能统计和报告出“最短寻找时间优先算法”下磁头响应请求的顺序、移臂的总量和掉头的次数。

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
void main()
{
int a[100],b[100],c[100];
int i,n,k,h,t,p,l,sum;
printf("请输入总磁道数：\n");
scanf("%d",&n);
printf("请输入磁道:\n");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
for(i=0;i<n-1;i++)
for(k=i+1;k<n;k++)
if(a[i]>a[k])
{
h=a[i];
a[i]=a[k];
a[k]=h;
}
printf("排序后的数组为：\n");
for(i=0;i<n;i++)
printf("%d\n",a[i]);
printf("请输入当前磁道数：\n");
scanf("%d",&p);
for(i=0;i<n;i++)
if(a[i]<=p && a[i+1]>=p)
{
printf("在第%d个位置插入\n",i);
break;
}
t=0;//输出数组下标
l=i+1;
while(i>0 || l<=n)
{
if((p-a[i])<(a[l]-p))
{
c[t]=p-a[i];
b[t++]=a[i];
p=a[i];
i--;
}
else
{
c[t]=a[l]-p;
b[t++]=a[l];
p=a[l];
l++;
}
}
i--;
if(i==0)
while(l<=n)
b[t++]=a[l++];
else
while(i>=0)
b[t++]=a[i--];
printf("SSTF磁头移动顺序和相应的移动距离为：\n");
for(k=0;k<n;k++)
printf("%d %d\n",b[k],c[k]);
printf("磁道移动总量为：");
sum=0;
for(k=0;k<n;k++)
sum=sum+c[k];
printf("%d\n",sum);
return 0;
}
第6章与并发进程有关的系统功能调用实践作业
参照“强化实践能力培养课程内容”中“进程的同步与互斥实践能力培养考核选例”程序和“文件操作实践能力培养考核选例”程序，请在计算机上实现教材第6章习题6要求的功能。

现有四个进程R1、R2、W1和W2，它们共享可以存放一个数的缓冲器B。

进程R1每次把从磁盘上读入的一个数存到缓冲器B中，供进程W1打印输出。

进程R2每次把从键盘上读入的数存到缓冲器B中，供进程W2打印输出。

当一个进程把数存放到缓冲器后，在该数还没有被打印输出之前不准任何进程再向缓冲器中存数。

当一个进程已把缓冲器中的数打印输出后，在缓冲器还没有存入一个新数之前不准任何进程再从缓冲器中取数打印。

怎样用ＰＶ操作使这四个进程并发执行时能协调的工作？
S：表示能否把数存人缓冲器B，初始值为1。

S1：表示R1是否已向缓冲器存入从键盘上读入的一个数，初始值为0。

S2：表示R2是否已向缓冲器存入从磁盘上读入的一个数，初始值为0。

begin
S，S1，S2：semaphore；
S：＝1；S1：＝S2：＝0；
cobegin
process R1
xl :integer
begin
L1：从键盘读一个数；
x1：=读入的数；
P（S）；
B：＝xl；
V（S1）；
goto L1；
end；
process R2
x2：integer；
begin
L2：从磁盘读一数；
x2：=读入的数；
P（S）；
B：＝x2；
V（S2）；
goto L2；
end；
process W1
y：integer；
begin
L3：P（S1）；
y：=B；
V（S）；
打印y中的数；
goto L3；
end；
process W2
z：integer
begin
L4：P（S2）；
z：=B；
V（S）；
打印z中的数；
goto L4；
end； coend； end．。