本科实验报告
课程名称：操作系统B
实验项目：操作系统实验实验地点：
专业班级：学号：学生姓名：
指导教师：
年月日
实验一实验题目
一、实验目的和要求（必填）
（一）目的
本实验的目的是使学生熟悉1—2种操作系统的界面，在熟练使用机器的基础上，能了解各种操作命令和系统调用在系统中的大致工作过程。也就是通过操作系统的外部特征，逐步深入到操作系统的内部实质内容中去。
（二）要求
1.能熟练的在1—2种操作系统的环境下工作，学会使用各种命令，熟悉系统提供的各种功能，主动而有效地使用计算机。
2. 熟悉系统实用程序的调用方法和各种系统调用模块的功能和作
二、实验内容和原理
在某种操作系统的环境下建立、修改、运行、打印源程序和结果，最后撤消一个完整的程序。
提示：可按下述步骤进行
1．编写一个完整的源程序，通过编辑命令送入机器，建立源程序文件；
2．编译该源文件，建立相应的目标文件；
3．编译有错时，再用编辑命令修改源文件，消除全部词法和语法错误；
4．连接目标文件，形成可执行文件；
5．执行该文件，得到结果；
6．打印输出源程序和运行结果；
7．撤消本次实验中形成的所有文件。
三、主要仪器设备
HP6450b
四、操作方法与实验步骤
#include
#include
#include
#include
#define SEM_NAME "mysem"
#define OPEN_FLAG O_RDWR|O_CREAT
#define OPEN_MODE 00777
#define INIT_V 0
static sem_t *sem = NULL;
static void mysem(char *str)
{
int i = 0;
while('\0' != str[i])
{
printf("%c\n", str[i++]);
sleep(1);
}
}
int main(void)
{
pid_t pid = -1;
int ret = -1;
int status = -1;
//创建一个命名信号量
sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V);
//创建子进程
pid = fork();
if(-1 == (ret = pid))
{
perror("fork failed: ");
goto _OUT;
}
if(0 == pid)
{
mysem("abcd");
//V操作
sem_post(sem);
}
if(0 < pid)
{
//P操作
sem_wait(sem);
mysem("1234");
//等待子进程结束
wait(&status);
//删掉在系统创建的信号量
sem_unlink(SEM_NAME);
//彻底销毁打开的信号量
sem_close(sem);
}
_OUT:
return ret;
}
五、实验数据记录和处理
六讨论、心得
本次实验是对linux的初识，通过实验我了解了linux系统的一些基本特性，了解了linux的shell命令，shell是用户和Linux内核之间的接口程序，如果把Linux内核想象成一个球体的中心，shell就是围绕内核的外层。就好像dos系统的command命令一样，但是还有些差别，同时我体会到linux VI编辑器不是很好使用，删除和修改都不是很好操作。
实验二 进程调度程序设计
一、目的和要求
（一） 目的
进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验可使学生加深对进程调度和各种调度算法的理解。 （二） 要求
1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB)表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占用CPU 的时间以及进程的状态等，且可按照调度算法的不同而增删。
2． 调度程序应包含2—3种不同的调度算法，运行时可以任选一种，以利于各种方法的分析和比较。
3.系统应能显示或打印各进程状态和参数的变化情况，便于观察。
二、实验内容和原理。
1． 题目 本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假定起始状态都是就绪状态W 。
为了便于处理，程序中进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。
2． 进程控制块结构如表2-1所示：
表2-1 PCB
进程标识符 链指针 优先数/轮转时间片数 占用CPU 时间片数 进程所需时间片数 进程状态
进程控制块链结构如图2-1所示：
RUN HEAD TAIL
…
图2-1 进程控制块链结构
其中：RUN —当前运行进程指针；
1 ┇
R 3 ┇
W 5 ┇
W W
┇
2
HEAD —进程就绪链链首指针； TAIL —进程就绪链链尾指针。
2. 算法与框图 程序框图如图2-2所示。
图2-2 进程调度框图
(1)优先数法。 进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。理由是该进程如果在一个时间片中完成不了，优先级应降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。 进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。
priority
是 输入调度算法alog
开始
alog=priority/round robin?
生成并按优先数大小排列进程控制块链 进程时间片数为0？
从链首取一个进程投入运行
生成并按进入次序 排列进程控制块链 链首进程投入运行
时间片到，进程时间片 数减1，优先数减3
运行进程退出，排到进程链尾部
撤消该进程 链首进程投入运行 时间片到，进程时间片数 减1，占用CPU 时间加1
优先数大于链首进程? 进程时间片数为0？
撤消该进程 运行进程退出，按优先数插入进程链
从链首取一个进程投入运行
结束
结束
进程队列空?
进程队列空?
是
是
是
否
否
否
否
否
是 round robin
占用处理机时间片到?
否
是
进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项位置）。每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
三、主要仪器设备
HP，REDHAT,VMware Workstation。
四、操作方法与实验步骤
程序清单：
#include
#include
#define furthest 5
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;
main() /*MAIN PROGRAM*/
{
agan: printf(“type the algorithm is (1:RR,2:PRIO):”);
scanf(“%d”,&algo);
if (algo==2)
{ printf(“output of priority.\n”);
init();
prisch();}
else
{ if (algo==1)
{ printf(“output of round robin.\n”);
init();
timesch();}
else
{ printf(“try again,please\n”);
goto agan;}
}
for (j=1;j<=40;j++)
{ printf(“=”); }
printf(“\n\n”);
for (j=1;j<=40;j++)
{ printf(“=”); }
printf(“\n\n”);
printf(“system finished\n);
}
print() /*PRINT THE RUNNING PROCESS,WAITING
QUEUE AND PCB SEQUENCE LIST*/ { int k,p;
for (k=1;k<=40;k++)
printf(“=”);
printf(“\nrunning proc. ”);
printf(“waiting queue.”);
printf(“\n %d ”,prochain[run].id);
p=head;
while(p!=0)
{ printf(“%5d”,p);
p=prochain[p].next;}
printf(“\n”);
for (k=1;k<=40;k++)
printf(“=”);
printf(“\n”);
printf(“ id “);
for (k=1;k printf(“%5d”,prochain[k].id); printf(“\n”); printf(“priority ”); for (k=1;k printf(“%5d”,prochain[k].priority); printf(“\n”); printf(“cputime ”); for (k=1;k printf(“%5d”,prochain[k].cputime); printf(“\n”); printf(“alltime ”); for (k=1;k printf(“%5d”,prochain[k].alltime); printf(“\n”); printf(“state ”); for (k=1;k printf(“%5c”,prochain[k].state); printf(“\n”); printf(“next ”); for (k=1;k printf(“%5d”,prochain[k].next); printf(“\n”); } insert(int q) /*INSERT A PROCESS*/ { int p,s; p=head; s=prochain[head].next while((prochain[q].priority s=prochain[s].next;} prochain[p].next=q; prochain[q].next=s; } insert2() /*PUT A PROCESS ONTO THE TAIL OF THE QUEUE*/ { prochain[tail].next=run; tail=run; prochain[run].next=0; } init() /*CREATE A WAITING QUEUE*/ { int i; head=0; if (alog==2) { for (i=1;i { 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 priority)&&(head!=0)) insert(prochain[i].id); else { prochain[i].next=head; head= prochain[i].id;} } } else { for (i=1;i { 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);} head=1; tail=furthest; prochain[furthest].next=0; } run=head; prochain[run].state=’R’; head=prochain[head].next; prochain[run].next=0; print(); } 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) { run=head; prochain[run].state=’R’; head=prochain[head].next;} else { 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(); } } timesch() /*THE PROCESS WITH RR ALRORITHM*/ { while(run!=0) { prochain[run].alltime-=1; prochain[run].cputime+=1; if(prochain[run].alltime==0) { prochain[run].state=’F’; prochain[run].next=0; if(head!=0) { run=head; prochain[run].state=’R’; head=prochain[head].next;} else { prochain[0].id=prochain[run].id; run=0;} } else { if((prochain[run].cputime==prochain[run]. priority)&&(head!=0)) { prochain[run].state=’W’; prochain[run].cputime=0; insert2(); run=head; prochain[run].state=’R’; head=prochain[head].next;} } print(); } } 五、实验数据记录和处理 六、讨论、心得 通过本次实验我了解了优先数调度算法和时间片轮转调度算法的设计理念，全面的认识了他们的优缺点和适用的环境，同时对进程有了一个深入的了解，对以后操作系统的学习奠定了一定的基础。 实验三存储管理程序设计 一、目的和要求 （一）目的 存储管理的主要功能之一是合理地分配主存空间。请求页式管理是一种常用的虚拟存储管理技术。 本实验的目的是通过请求页式存储管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 （二）要求 模拟页式虚拟存储管理中硬件的地址转换和缺页中断的处理过程，并用先进先出调度算法（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”。 图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所示。 j ∶= P[k] j 页的修改标志=1? 输出“OUTj ” P[k]∶=L k ∶=(k+1) mod m 修改页表 输出“IN L ” 取一条指令 开始 页标志=1? 输出绝对地址 取一条指令 输出“﹡页号” 取指令中访问的页号＝＞L 查页表 形成绝对地址 置L 页修改标志”1” 结束 是”存”指令? 有后继指令? 否(产生缺页中断) 是 否 否 否 是 是 模拟硬件 地址转换 模拟FIFO 页面调度 是 表3-2 作业的页表 页号标志位主存块号修改标志在磁盘上的位置 0 1 5 0 011 1 1 8 0 012 2 1 9 0 013 3 1 1 0 021 4 0 0 022 5 0 0 023 6 0 0 121 如果该作业依次执行的指令序列如表3-3所示。 表3-3 作业依次执行的指令序列 操作页号页内地址操作页号页内地址 + 0 070 移位 4 053 + 1 050 + 5 023 × 2 015 存 1 037 存 3 021 取 2 078 取 0 056 + 4 001 - 6 040 存 6 084 依次执行上述的指令序列来调试你所设计的程序（仅模拟指令的执行，不必考虑指令序列中具体操作的执行） (5)为了检查程序的正确性，可自行确定若干组指令序列，运行设计的程序，核对执行结果。 三、主要仪器设备 HP，REDHAT，VMware Workstation。 四、操作方法与实验步骤 程序清单： #include #include #define NUM 7 #define WNUM 12 struct pagetable { int num;//页号 int flag;//标志 int block;//主存块号 int modify;//修改标志 int location;//磁盘上的位置 }; //主存块号是-1说明该页没有调入主存 struct pagetable page[NUM]={{0,1,5,0,010},{1,1,8,0,012},{2,1,9,0,013},{3,1,1,0,021},{4,0,-1,0,022},{5,0, -1,0,023},{6,0,-1,0,121}}; struct work { char operation[10];//操作 int pagenum;//页号 int address;//页内地址 }; struct work w[WNUM]={{"+",0,70},{"+",1,50},{"*",2,15},{"存",3,21}, {"取",0,56},{"-",6,40},{"移位",4,53},{"+",5,23}, {"存",1,37},{"取",2,78},{"+",4,1},{"存",6,84}}; void main() { int k=0;//当要装入新页时应调出的页在数组的位置 int m=4;//允许分配的最大块数 int curpage = 0;//当前页号 int p[4] = {0,1,2,3};//当前已在主存中的页面 int replace;//替换页的页号 int tempflag; int tempmodify; long memoryaddress;//物理地址（绝对地址） printf("\n 操作 \t 页号 \t页内地址标志绝对地址修改页号绝对地址修改标志\n"); for(int i=0;i { curpage = w[i].pagenum; tempflag = page[curpage].flag; if(page[curpage].flag == 0) { replace = p[k]; p[k] = curpage; k=(k+1)%m; page[curpage].flag = 1; page[curpage].block = page[replace].block; tempmodify = page[replace].modify; page[replace].block = -1; page[replace].flag = 0; page[replace].modify = 0; } memoryaddress = 1024*page[curpage].block+w[i].address; if(!strcmp(w[i].operation,"存") || !strcmp(w[i].operation,"写")) page[curpage].modify=1; else page[curpage].modify=0; printf(" %s\t",w[i].operation); printf(" %d\t",w[i].pagenum); printf(" %d\t",w[i].address); printf(" %d\t",tempflag); if(tempflag==1) printf(" %d\t",memoryaddress); else printf(" *%d\t",w[i].pagenum); if(tempflag==1) printf(" \t"); else printf(" %d->%d\t",w[i].pagenum,replace); printf(" %d\t",memoryaddress); printf(" %d\t",page[curpage].modify); printf("\n"); } } 五、实验数据记录和处理 六、讨论、心得 本实验是通过请求页式存储管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。通过本次实验了解了存储管理技术，掌握了请求页式存储管理的原理和工作过程，强化了页面置换的概念，更为系统的了解了os对存储管理的算法，对操作系统有了一个高度的认识。 实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图 2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0; 重庆大学 学生实验报告 实验课程名称操作系统原理 开课实验室DS1501 学院软件学院年级2013专业班软件工程2 班学生姓名胡其友学号20131802 开课时间2015至2016学年第一学期 总成绩 教师签名洪明坚 软件学院制 《操作系统原理》实验报告 开课实验室：年月日学院软件学院年级、专业、班2013级软件工 程2班 姓名胡其友成绩 课程名称操作系统原理 实验项目 名称 指导教师洪明坚 教师 评语教师签名：洪明坚年月日 1．实验目的： ?进入实验环境 –双击expenv/setvars.bat ?检出（checkout）EPOS的源代码 –svn checkout https://www.doczj.com/doc/9e5343004.html,/svn/epos ?编译及运行 –cd epos/app –make run ?清除所有的临时文件 –make clean ?调试 –make debug ?在“Bochs Enhanced Debugger”中，输入“quit”退出调试 –调试指令，请看附录A 2．实验内容： ?编写系统调用“time_t time(time_t *loc)” –功能描述 ?返回从格林尼治时间1970年1月1日午夜起所经过的秒数。如果指针loc 非NULL，则返回值也被填到loc所指向的内存位置 –数据类型time_t其实就是long ?typedef long time_t; 3．实验步骤： ?Kernel space –K1、在machdep.c中，编写系统调用的实现函数“time_t sys_time()”，计算用户秒数。需要用到 ?变量g_startup_time，它记录了EPOS启动时，距离格林尼治时间1970年1午夜的秒数 ?变量g_timer_ticks 操作系统实验报告 ' 学号： 姓名： 指导老师： 完成日期： ~ 目录 实验一 (1) 实验二 (2) 实验三 (7) 实验四 (10) 实验五 (15) 实验六 (18) 实验七 (22) \ 实验一 UNIX/LINUX入门 一、实验目的 了解 UNIX/LINUX 运行环境，熟悉UNIX/LINUX 的常用基本命令，熟悉和掌握UNIX/LINUX 下c 语言程序的编写、编译、调试和运行方法。 二、实验内容 熟悉 UNIX/LINUX 的常用基本命令如ls、who、pwd、ps 等。 练习 UNIX/LINUX的文本行编辑器vi 的使用方法 熟悉 UNIX/LINUX 下c 语言编译器cc/gcc 的使用方法。用vi 编写一个简单的显示“Hello,World!”c 语言程序，用gcc 编译并观察编译后的结果，然后运行它。 三、实验要求 按照要求编写程序，放在相应的目录中，编译成功后执行，并按照要求分析执行结果，并写出实验报告。 四、实验程序 #include <> #include <> int main() { printf ("Hello World!\n"); return 0; } 五、实验感想 通过第一次室验，我了解 UNIX/LINUX 运行环境，熟悉了UNIX/LINUX 的常用基本命令，熟悉和掌握了UNIX/LINUX 下c 语言程序的编写、编译、调试和运行方法。 实验二进程管理 一、实验目的 加深对进程概念的理解，明确进程与程序的区别；进一步认识并发执行的实质。 二、实验内容 （1）进程创建 编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示“a“；子进程分别显示字符”b“和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程控制 修改已编写的程序，将每一个进程输出一个字符改为每一个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 （3）进程的管道通信 编写程序实现进程的管道通信。使用系统调用pipe()建立一个管道，二个子进程P1 和P2 分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 父进程从管道中读出二个来自子进程的信息并显示（要求先接收P1，再接收P2）。 三、实验要求 按照要求编写程序，放在相应的目录中，编译成功后执行，并按照要求分析执行结果，并写出实验报告。 四、实验设计 1、功能设计 （1）进程创建 使用fork（）创建两个子进程，父进程等待两个子进程执行完再运行。 （2）进程控制 使用fork（）创建两个子进程，父进程等待两个子进程分别输出一句话再运行。 （3）进程的管道通信 先创建子进程1，向管道写入一句话，子进程1结束后创建子进程2，向管道写入一句话，最后父进程从管道中读出。 2、数据结构 子进程和管道。 3、程序框图 计算机操作系统综合设计 实验一 实验名称：进程创建模拟实现 实验类型：验证型 实验环境： win7 vc++6.0 指导老师： 专业班级： 姓名： 学号： 联系电话： 实验地点：东六E507 实验日期：2017 年 10 月 10 日 实验报告日期：2017 年 10 月 10 日 实验成绩： 一、实验目的 1）理解进程创建相关理论； 2）掌握进程创建方法； 3）掌握进程相关数据结构。 二、实验内容 windows 7 Visual C++ 6.0 三、实验步骤 1、实验内容 1)输入给定代码； 2)进行功能测试并得出正确结果。 2、实验步骤 1）输入代码 A、打开 Visual C++ 6.0 ； B、新建 c++ 文件，创建basic.h 头文件，并且创建 main.cpp 2）进行功能测试并得出正确结果 A 、编译、运行main.cpp B、输入测试数据 创建10个进程；创建进程树中4层以上的数型结构 结构如图所示：。 createpc 创建进程命令。 参数： 1 pid（进程id）、 2 ppid（父进程id）、3 prio（优先级）。 示例：createpc(2,1,2) 。创建一个进程，其进程号为2，父进程号为1，优先级为2 3)输入创建进程代码及运行截图 4）显示创建的进程 3、画出createpc函数程序流程图 分析createpc函数的代码，画出如下流程图： 四、实验总结 1、实验思考 (1)进程创建的核心内容是什么？ 答： 1)申请空白PCB 2)为新进程分配资源 3)初始化进程控制块 4)将新进程插入到就绪队列 （2）该设计和实际的操作系统进程创建相比，缺少了哪些步骤？ 答:只是模拟的创建，并没有分配资源 2、个人总结 通过这次课程设计，加深了对操作系统的认识，了解了操作系统中进程创建的过程，对进程创建有了深入的了解，并能够用高 级语言进行模拟演示。一分耕耘，一分收获，这次的课程设计让 我受益匪浅。虽然自己所做的很少也不够完善，但毕竟也是努 力的结果。另外，使我体会最深的是：任何一门知识的掌握， 仅靠学习理论知识是远远不够的，要与实际动手操作相结合才能 达到功效。 中南大学信息科学与工程学院实验报告 姓名：安磊 班级：计科0901 学号： 0909090310 指导老师：宋虹 目录 课程设计内容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------6 文件系统的层次结构和功能模块 ---------------------6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录-------------------------------------------------- 12 课程设计内容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在内存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统内核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小内核可编译至2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统内核，它仅仅包含了任务调度，任务管理，时间管理，内存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全 可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时内核，并在这个内核之上提供最基本的系统服务，如信号量，邮箱，消息队列，内存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图： 《操作系统》实验报告 实验序号： 4 实验项目名称：进程控制 Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜ 修改后: #include 实验任务:写出程序的运行结果。 4．正在运行的进程 （2）、编程二下面给出了一个使用进程和操作系统版本信息应用程序(文件名为4-5.cpp)。它利用进程信息查询的API函数GetProcessVersion()与GetVersionEx()的共同作用。确定运行进程的操作系统版本号。阅读该程序并完成实验任务。 #include 中央广播电视大学计算机科学与技术专业操作系统（本科） 实验报告 院系：_______________ 班级：________ 学生姓名：_____________ 学号：______ 指导教师：________ 完成日期2015年月日 一、实验题目： Linux应用及shell编程 二、实验目的和要求： 目的 1．掌握Linux一般命令格式和常用命令。 2．学会使用vi编辑器建立、编辑文本文件。 3．了解shell的作用和主要分类。 4．学会bash脚本的建立和执行方式。 5．理解bash的基本语法。 6．学会编写简单的shell脚本。 要求 1．登录进入系统，修改个人密码。 2．使用简单命令：date，cal，who，echo，clear等，了解Linux命令格式。 3．进入vi。建立一个文件，如。进入插入方式，输入一个C语言程序的各行内容，故意制造几处错误。最后，将该文件存盘。回到shell状态下。 4．运行，编译该文件，会发现错误提示。理解其含义。 5．利用vi建立一个脚本文件，其中包括date，cal，pwd，ls等常用命令。然后以不同方式执行该脚本。 6．对主教材第2章中的适当例题进行编辑，然后执行。从而体会通配符、引号、输入输出重定向符、成组命令的作用；能正确使用自定义变量、位置参数、环境变量、输入/输出命令；能利用if语句、while语句、for语句和函数编写简单的脚本。 三、实验内容： 1．正确地登录和退出系统。 2．熟悉使用ls,cp,cat,等常用命令。 3．进入和退出vi。利用文本插入方式建立一个文件。 5．建立简单shell脚本并执行它。 四、实验技术和方法： Linux中各种脚本语言 五、实验环境： 虚拟机，ubuntuserver版，shell 六、实验步骤和结果： 1．正确地登录和退出系统。 使用exit命令退出系统 2．熟悉使用cat,cd,cp,ls,mor,rm,vi,who等常用命令。 2．使用vi编写 按：wq存储，并退出 5．建立shell脚本并执行它。 使用VI创建ex1文件,内容含三条命令date/pwd/cd.. 七、实验结果分析： 无 实训3 一、实验题目： 进程管理 二、实验目的和要求： 目的 1．加深对进程概念的理解，明确它与程序的区别，突出理解其动态性特征。 实时操作系统课程实验报告 专业：通信1001 学号：3100601025 姓名：陈治州 完成时间：2013年6月11日 实验简易电饭煲的模拟 一．实验目的： 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，基于多任务的模式的编程方法。锻炼综合应用多任务机制，任务间的通信机制，内存管理等的能力。 二．实验要求： 1.按“S”开机，系统进入待机状态，时间区域显示当前北京时间，默认模式“煮饭”; 2.按“C”选择模式，即在“煮饭”、“煮粥”和“煮面”模式中循环选择； 3.按“B”开始执行模式命令，“开始”状态选中，时间区域开始倒计时，倒计时完成后进入“保温”状态，同时该状态显示选中，时间区域显示保温时间； 4.按“Q”取消当前工作状态，系统进入待机状态，时间区域显示北京时间，模式为当前模式； 5.按“X”退出系统，时间区域不显示。 6.煮饭时长为30，煮粥时长为50，煮面时长为40. 三．实验设计： 1.设计思路： 以老师所给的五个程序为基础，看懂每个实验之后，对borlandc的操作有了大概的认识，重点以第五个实验Task_EX为框架，利用其中界面显示与按键扫描以及做出相应的响应，对应实现此次实验所需要的功能。 本次实验分为界面显示、按键查询与响应、切换功能、时钟显示与倒计时模块，综合在一起实验所需功能。 2.模块划分图： （1）界面显示： Main（） Taskstart（） Taskstartdispinit（） 在TaskStartDispInit()函数中，使用PC_DispStr()函数画出界面。 （2）按键查询与响应： Main（） Taskstart（） 在TaskStart()函数中，用if (PC_GetKey(&key) == TRUE)判断是否有按键输入。然后根据key 的值，判断输入的按键是哪一个；在响应中用switch语句来执行对应按键的响应。 （3）切换功能： l计数“C”按 键的次数 M=l%3 Switch(m) M=0，1，2对应于煮饭，煮粥，煮面，然后使用PC_DispStr()函数在选择的选项前画上“@”指示，同时，在其余两项钱画上“”以“擦出”之前画下的“@”，注意l自增。 四.主要代码： #include "stdio.h" #include "includes.h" #include "time.h" #include "dos.h" #include "sys/types.h" #include "stdlib.h" #define TASK_STK_SIZE 512 #define N_TASKS 2 OS_STK TaskStk[N_TASKS][TASK_STK_SIZE]; OS_STK TaskStartStk[TASK_STK_SIZE]; INT8U TaskData[N_TASKS]; 操作系统教程 实 验 指 导 书 姓名： 学号： 班级：软124班 指导老师：郭玉华 2014年12月10日 实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序： E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： 有可能是因为DOS下路径的问题 （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 因为程序是个死循环程序 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环： 屏蔽j循环： _______________________________________________________________________________调整循环变量i的循环次数： 操作系统实验报告 集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289- 实验二进程调度1．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 2．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。 程序要求如下： 1）输出系统中进程的调度次序； 2）计算CPU利用率。 3．实验环境 Windows操作系统、VC++6.0 C语言 4设计思想： （1）程序中进程可用PCB表示，其类型描述如下： structPCB_type { intpid;//进程名 intstate;//进程状态 2——表示“执行”状态 1——表示“就绪”状态 0——表示“阻塞”状态 intcpu_time;//运行需要的CPU时间（需运行的时间片个数） } 用PCB来模拟进程； （2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。队列类型描述如下： structQueueNode{ structPCB_typePCB; StructQueueNode*next; } 并设全程量： structQueueNode*ready_head=NULL,//ready队列队首指针 *ready_tail=NULL,//ready队列队尾指 针 操作系统原理试验报告 班级： 学号： 姓名： 实验一：CPU调度 一、实验内容 选择一个调度算法，实现处理机调度。 二、实验目的 多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度，以加深了解处理机调度的工作。 三、实验题目 1、设计一个按优先权调度算法实现处理机调度的程序； 2、设计按时间片轮转实现处理机调度的程序。 四、实验要求 PCB内容： 进程名/PID； 要求运行时间（单位时间）； 优先权； 状态： PCB指针； 1、可随机输入若干进程，并按优先权排序； 2、从就绪队首选进程运行：优先权-1/要求运行时间-1 要求运行时间=0时，撤销该进程 3、重新排序，进行下轮调度 4、最好采用图形界面； 5、可随时增加进程； 6、规定道数，设置后备队列和挂起状态。若内存中进程少于规定道数，可自动从后备 队列调度一作业进入。被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。 7、每次调度后，显示各进程状态。 实验二：内存管理 一、实验内容 主存储器空间的分配和回收 二、实验目的 帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。 三、实验题目 在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收。 四、实验要求 1、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表； 表目内容：起址、长度、状态（未分/空表目） 2、结合实验一，PCB增加为： {PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，PCB指针} 3、采用最先适应算法分配主存空间； 4、进程完成后，回收主存，并与相邻空闲分区合并 .1、Vo类说明（数据存储结构） 进程控制块PCB的结构： Public class PCB{ //进程控制块PCB，代表一个进程 //进程名，作为进程的标识； private String name; //要求运行时间，假设进程运行的单位时间数； private int time; //赋予进程的优先权，调度时总是选取优先数小的进程先执行； private int priority; //状态，假设有“就绪”状态（ready）、“运行”状态（running）、 //“后备”状态（waiting）、“挂起”状态(handup) private String state; //进程存放在table中的位置 private int start; //进程的大小 private int length; //进程是否进入内存，1为进入，0为未进入 private int isIn; //进程在内存中的起始位置 private int base; //进程的大小 private int limit; //一些get和set方法以及构造器省略… }; 西安邮电大学 （计算机学院） 课实验报告 实验名称：进程管理 专业名称：计算机科学与技术 班级： 学生： 学号（8位）： 指导教师： 实验日期：*****年**月**日 一. 实验目的及实验环境 目的：（1）加深对进程概念的理解，明确进程和程序的区别。 （2）进一步认识并发执行的实质。 （3）分析进程竞争资源现象，学习解决进程互斥的方法。 （4）了解Linux系统中进程通信的基本原理。 环境：Linux操作系统环境： 二. 实验容 （1）阅读Linux的sched.h源文件，加深对进程管理概念的理解。 （2）阅读Linux的fork.c源文件，分析进程的创建过程。 三．方案设计 （1）进程的创建 编写一段源程序，使系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。试观察纪录屏幕上的显示结果，并分析原因。（2）进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。 如果在程序中使用调用lockf()来给每一个子进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。 （3）①编写一段程序，使其现实进程的软中断通信。 要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Processll is Killed by Parent! Child Processl2 is Killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止 Parent Process is Killed! 程序流程图如下： 嵌入式实时操作系统实验报告 任务间通信机制的建立 系别计算机与电子系 专业班级***** 学生姓名****** 指导教师 ****** 提交日期 2012 年 4 月 1 日 一、实验目的 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，任务使用信号量的一般原理。掌握在基于优先级的可抢占嵌入式实时操作系统的应用中，出现优先级反转现象的原理及解决优先级反转的策略——优先级继承的原理。 二、实验内容 1.建立并熟悉Borland C 编译及调试环境。 2.使用课本配套光盘中第五章的例程运行（例5-4,例5-5，例5-6），观察运行结果，掌握信号量的基本原理及使用方法，理解出现优先级反转现象的根本原因并提出解决方案。 3.试编写一个应用程序，采用计数器型信号量（初值为2），有3个用户任务需要此信号量，它们轮流使用此信号量，在同一时刻只有两个任务能使用信号量，当其中一个任务获得信号量时向屏幕打印“TASK N get the signal”。观察程序运行结果并记录。 4. 试编写一个应用程序实现例5-7的内容，即用优先级继承的方法解决优先级反转的问题，观察程序运行结果并记录。 5.在例5-8基础上修改程序增加一个任务HerTask,它和YouTask一样从邮箱Str_Box里取消息并打印出来，打印信息中增加任务标识，即由哪个任务打印的；MyTask发送消息改为当Times为5的倍数时才发送，HerTask接收消息采用无等待方式，如果邮箱为空，则输出“The mailbox is empty”, 观察程序运行结果并记录。 三、实验原理 1. 信号量 μC/OS-II中的信号量由两部分组成：一个是信号量的计数值，它是一个16位的无符号整数（0 到65,535之间）；另一个是由等待该信号量的任务组成的等待任务表。用户要在OS_CFG.H中将OS_SEM_EN开关量常数置成1，这样μC/OS-II 才能支持信号量。 操作系统教程实验报告 专业班级 学号 姓名 指导教师 实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环： 《操作系统原理》实验报告 实验项目名称:模拟使用银行家算法判断系统的状态 一、实验目的 银行家算法是操作系统中避免死锁的算法，本实验通过对银行家算法的模拟，加强对操作系统中死锁的认识，以及如何寻找到一个安全序列解除死锁。 二、实验环境 1、硬件：笔记本。 2、软件：Windows 7 , Eclipse。 三、实验内容 1.把输入资源初始化，形成资源分配表； 2.设计银行家算法，输入一个进程的资源请求，按银行家算法步骤进行检查； 3.设计安全性算法，检查某时刻系统是否安全； 4.设计显示函数，显示资源分配表，安全分配序列。 四、数据处理与实验结果 1.资源分配表由进程数组，Max，Allocation，Need，Available 5个数组组成； 实验采用数据为下表： 2.系统总体结构，即菜单选项，如下图 实验的流程图。如下图 3.实验过程及结果如下图所示 1.首先输入进程数和资源类型及各进程的最大需求量 2.输入各进程的占有量及目前系统的可用资源数量 3.初始化后，系统资源的需求和分配表 4.判断线程是否安全 5.对线程进行死锁判断 五、实验过程分析 在实验过程中，遇到了不少问题，比如算法无法回滚操作，程序一旦执行，必须直接运行到单个任务结束为止，即使产生了错误，也必须等到该项任务结束才可以去选择别的操作。但总之，实验还是完满的完成了。 六、实验总结 通过实验使我对以前所学过的基础知识加以巩固，也对操作系统中抽象理论知识加以理解，例如使用Java语言来实现银行家算法，在这个过程中更进一步了解了银行家算法，通过清晰字符界面能进行操作。不过不足之处就是界面略显简洁，对于一个没有操作过计算机的人来说，用起来可能还是有些难懂。所以，以后会对界面以及功能进行完善，做到人人都可以看懂的算法。 学生学号0121210680225 实验课成绩 武汉理工大学 学生实验报告书 实验课程名称操作系统 开课学院计算机科学与技术学院 指导老师姓名刘军 学生姓名李安福 学生专业班级软件sy1201 2014 — 2015 学年第一学期 《操作系统》实验教学大纲 课程编号： 课程名称：操作系统/Operating System 实验总学时数：12学时 适应专业：计算机科学与技术、软件工程 承担实验室：计算机科学与技术学院实验中心 一、实验教学的目的和任务 通过实验掌握Linux系统下常用键盘命令、系统调用、SHELL编程、后台批处理和C程序开发调试手段等基本用法。 二、实验项目及学时分配 序号实验项目名称实验学时实验类型开出要求 01 Linux键盘命令和vi 2 设计必开 02 Linux下C编程 2 设计必开 03 SHELL编程和后台批处理 2 设计必开 04 Linux系统调用（time） 2 设计必开 05 Linux进程控制(fork) 4 设计必开 三、每项实验的内容和要求: 1、Linux键盘命令和vi 要求：掌握Linux系统键盘命令的使用方法。 内容：见教材p4, p9, p40, p49-53, p89, p100 2、Linux下的C编程 要求：掌握vi编辑器的使用方法；掌握Linux下C程序的源程序编辑方法；编译、连接和运行方法。 内容：设计、编辑、编译、连接以及运行一个C程序，其中包含键盘输入和屏幕输出语句。 3、SHELL编程和后台批处理 要求：掌握Linux系统的SHELL编程方法和后台批处理方法。 内容：(1) 将编译、连接以及运行上述C程序各步骤用SHELL程序批处理完成，前台运行。 (2) 将上面SHELLL程序后台运行。观察原C程序运行时输入输出情况。 (3) 修改调试上面SHELL程序和C程序，使得在后台批处理方式下，原键 盘输入内容可以键盘命令行位置参数方式交互式输入替代原键盘输入内容， 然后输出到屏幕。 4、Linux系统调用使用方法。 实验报告 实验课程名称：操作系统 实验地点：南主楼七楼机房 2018—2019学年（一）学期 2018年 9月至 2019 年 1 月 专业： 班级： 学号： 姓名： 指导老师：刘一男 实验一 实验项目：分时系统模拟 实验学时：2实验日期： 2018-10-25 成绩： 实验目的利用程序设计语言模拟分时系统中多个进程按时间片轮转调度算法进行进程调度的过程； 假设有五个进程A，B，C，D，E，它们的到达时间及要求服务的时间分别为：进程名 A B C D E 到达时间0 1 2 3 4 服务时间 4 3 4 2 4 时间片大小为1，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：BDACE （1）修改时间片大小为2，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：ADBCE （2）修改时间片大小为4，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间. 顺序：ABCDE 1、思考 时间片的大小对调度算法产生什么影响？对计算机的性能产生什么影响？答：通过对时间片轮转调度算法中进程最后一次执行时间片分配的优化,提出了一种改进的时间片轮转调度算法,该算法具有更好的实时性,同时减少了任务调度次数和进程切换次数,降低了系统开销,提升了CPU的运行效率,使操作系统的性能得到了一定的提高。 A B C D E 时间片为1 周转时间12 9 14 8 13 3 3 3.5 4 3.25 带权周转 时间 时间片为2 周转时间8 12 13 7 13 2 4 3.25 3.5 3.25 带权周转 时间 时间片为4 周转时间 4 6 9 10 13 1 2 2.25 5 3.25 带权周转 时间 操作系统实验一实验报告 基本信息 1.1 实验题目 进程控制实验 1.2完成人 王召德 1.3报告日期 2015-4-8 实验内容简要描述 2.1实验目标 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和 体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过 程。掌握进程控制的方法,了解父子进程间的控制和协作关系。练习Linux 系统中 进程创建与控制有关的系统调用的编程和调试技术。 2.2实验要求 参考以上示例程序中建立并发进程的方法，编写一个多进程并发执行程序。父进程首先创建一个执行ls命令的子进程然后再创建一个执行ps命令的子进程，并控制ps 命令总在ls 命令之前执行。 2.3实验的软硬件环境 Ubuntu14.04 intelPC 报告的主要内容 3.1实验的思路 按照上面的实例，先生成一个子进程让其等待，然后生成第二个子进程，父进程等待其执行ps命令后唤醒第一个子进程执行ls即可。 3.2实验模型的描述 无 3.3主要数据结构的分析说明 无 3.4主要算法代码的分析说明 无 3.5项目管理文件的说明 无 实验过程和结果 4.1实验投入的实际学时数 1学时 4.2调试排错过程的记录 曾尝试让第二个子进程激活第一个子进程，结果发现当运行ps后，后面的代码将不再执行，所以不可行。 4.3多种方式测试结果的记录 实验结果： 父进程启动 (12239) ls子进程启动 (12240) ps子进程启动 (12241) PID TTY TIME CMD 12239 pts/27 00:00:00 born 12240 pts/27 00:00:00 born 12241 pts/27 00:00:00 ps ps子进程结束 (12241) 唤醒ls子进程 (12240) 键盘中断信号产生... ls子进程被唤醒 (12240) . born born.c~ hello.c pctl pctl.c~ pctl.o .. born.c helelo.h~ hello.c~ pctl.c pctl.h ls子进程结束 (12240) 父进程结束 (12239) 4.4实验结果的分析综合 无 实验的总结 父进程可以通过fork()函数生成子进程，子进程会从fork()函数开始执行原来的代码，当操作系统实验报告--实验一--进程管理
操作系统实验报告一
操作系统实验报告
计算机操作系统综合设计实验报告实验一
嵌入式操作系统实验报告
操作系统实验报告4
电大操作系统本科实验报告
实时操作系统报告
操作系统实验报告
操作系统实验报告
操作系统实验报告-中南大学
操作系统实验报告16487
嵌入式实时操作系统实验报告
操作系统实验报告
操作系统实验报告
操作系统实验报告.
操作系统实验报告
操作系统实验一实验报告
相关主题
文本预览