河南中医学院
《linux操作系统》课程设计报告
题目：基于Linux的进程调度模拟程序
所在院系：信息技术学院
专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗
指导教师：阮晓龙
完成日期：201X 年06 月22 日
目录
1. 课程设计题目概述3
2. 研究内容与目的4
3. 研究方法5
4. 研究报告6
5. 测试报告/实验报告7
6. 课题研究结论8
7. 总结9
1、课程设计题目概述
随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。
本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解
设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法
2. 研究内容与目的
操作系统由四大功能模块组成：进程管理、存储器管理、设备管理和文件管理，进程管理是其中最重要的一个模块。本文主要研究最高优先数优先的调度算法、先来先服务算法这两种调度算法，并且分析比较这两种算法的优缺点。
目的：进程是操作系统中最重要的概念，也是学习操作系统的关键。通过本次课程设计，要求理解进程的实质和进程管理的机制。掌握进程调度的工作流程以及进程调度的算法，并且分析比较这两种算法的优缺点。
3. 研究方法
3.1研究方法
3.1.1查找资料
通过查找资料了解到：
（1）优先数调度算法简介
优先数调度算法常用于批处理系统中。在进程调度中，每次调度时，系统把处理机分配给就绪队列中优先数最高的进程。它又分为两种：非抢占式优先数算法和抢占式优先数算法
在非抢占式优先数算法下，系统一旦把处理机分配给就绪队列中优先数最高的进程后，这个进程就会一直运行，直到完成或发生某事件使它放弃处理机，这时系统才能重新将处理机分配给就绪队列中的另一个优先数最高的进程。
在抢占式优先数算法下，系统先将处理机分配给就绪队列中优先数最高的进程度让它运行，但在运行的过程中，如果出现另一个优先数比它高的进程，它就要立即停止，并将处理机分配给新的高优先数进程。
（2）先来先服务算法
如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之首的那个进程调度到运行状态。也就说，它只考虑进程进入就绪队列的先后，而不考虑它的下一个CPU周期的长短及其他因素。
基本思想：先来先服务的作业调度算法：优先从后备队列中，选择一个或多个位于队列头部的作业，把他们调入内存，分配所需资源、创建进程，然后放入“就绪队列”
先来先服务的进程调度算法：从“就绪队列”中选择一个最先进入队列的进程，为它分配处理器，使之开始运行
原理：按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先分配处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件发生而不能继续运行时才释放处理机。
①、系统只要有按FIFO规则建立的后备作业队列或就绪进程队列即可，就是一个作业控制块JCB或进程控制块PCB加入队列时加在相应队列末尾。
②、调度退出队列时从相应队列首开始顺序扫描，将相关的JCB或PCB调度移出相应队列。
3.2实验方法
3.2.1模拟法
根据最高优先数优先的调度算法、先来先服务算法的进程调度机制的流程，进行模拟这两种算法的实验。
3.2.2控制法
进行实验时，输入进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态。
3.2.3观察法
观察实验的结果，分析进程调度流程。
3.2.4比较法
通过观察实验结果，比较两种调度算法的优缺点。
3.3可行性分析（课题理论上的要求、实践的可操作性、本人能力和现实条件（相关案例、资料等）的许可等内容）
3.3.1环境运行
在VMware-workstation-full-10.0.0-1295980上，导入CentOS操作系统，在CentOS操作系统上运行。
CentOS操作系统是Linux发行版之一，它是来自于Red Hat Enterprise Linux依照开放源代码规定释出的源代码所编译而成。相对于其他Linux 发行版，其稳定性值得信赖。
因为CentOS操作系统安装了gcc编译器，能编译C语言。
3.3.2实践的可操作性
在对linux进程调度机制以及调度算法进行深入分析后，根据对于最高优先数优先的调度算法采用最高优先数算法的动态优先数法则控制进程：系统把处理机分配给就绪队列中优先数最高的进程后，如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU，而先来先服务是从“就绪队列”中选择一个最先进入队列的进程，为它分配处理器，使之开始运行而制定实验方案的。
3.3.3本人能力
虽然我对linux的进程调度方面的知识还有很多不知道的知识，但我是在不断学习的，遇到不懂得就通过查资料或请教他人的方法，不断地学习。
4. 研究报告
4.1最高优先数优先的调度算法（抢占式）
4.1.1实验原理
1、进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。
2、每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
3、进程的优先数及需要的运行时间事先人为地指定。
4、每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
5、进程的运行时间以时间片为单位进行计算。
6、就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
7、采用最高优先数算法的动态优先数法则控制进程：如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8、每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
9、重复以上过程，直到所要进程都完成为止。
4.1.2实验内容
1、数据结构
（1）进程控制块结构PCB：是struct定义的结构体，定义如下：
typedef struct pcb
{
char qname[20];/*进程名*/
char state; /*进程状态*/
int super; /*进程优先级*/
int ndtime; /*进程需要运行的时间*/
int runtime; /*进程已运行的时间*/
int cpu; /*进程当前获得的时间片大小*/
}PCB;
（2）队列结点Node，结点储存PCB信息，定义如下：
typedef struct node
{
PCB data; /*结点数据*/
struct node *next; /*指向下一结点的指针*/
}Node;
（3）由队列结点Node扩展的队列Queue,定义如下：
typedef struct queue
{
Node *front;/*队首*/
Node *rear;/*队尾*/
}Queue;
2．相关函数
（1）判断一个队列q是否为空的函数int is_empty(Queue *q);
（2）将进程控制块x加入队列q的函数void enqueue(PCB x,Queue *q);
（3）删除队列q的队首进程，将其值赋给x并修改状态的函数void dequeue(PCB *x,Queue *q);该函数将队列q的队首进程删除，由于可能该进程未运行完毕，需进入下一优先级队列，所以先修改其结构体内成员变量：已运行时间为上次已运行时间加上这次获得的cpu时间；优先级减1（若该进程已是最低优先级，则将在主控过程中恢复）；下次获得的时间片为这次的时间片加1。然后将修改后的进程赋给一个临时PCB变量x，以便将x插入下一优先级队列。
（4）主函数
利用上述的数据结构和函数实现模拟进程调度。
3. 进程产生模拟
通过标准输入模拟产生进程：先要求输入进程数目，再依次输入各个进程的进程名、进程优先数、进程需要运行的时间。
4.1.3参考代码
#include
#include
#include
#include
#define PCB_LEN sizeof(PCB)
#define NODE_LEN sizeof(Node)
#define QUEUE_LEN sizeof(Queue)
/*进程控制块结构PCB*/
typedef struct pcb
{
char qname[20];/*进程名*/
char state; /*进程状态*/
int super; /*进程优先级*/
int ndtime; /*进程需要运行的时间*/
int runtime; /*进程已运行的时间*/
int cpu; /*进程当前获得的时间片大小*/
}PCB;
/*队列结点，结点储存PCB信息*/
typedef struct node
{
PCB data;
struct node *next;
}Node;
/*实现进程控制块的队列*/
typedef struct queue
{
Node *front;
Node *rear;
}Queue;
/*判断队列是否为空*/
int is_empty(Queue *q)
{
if(q->front)
return 0;
else
return 1;
}
/*将进程控制块x加入队列q*/
void enqueue(PCB x,Queue *q)
{
Node *p=(Node *)malloc(NODE_LEN);
(p->data).state=x.state;
(p->data).super=x.super;
(p->data).ndtime=x.ndtime;
(p->data).runtime=x.runtime;
(p->data).cpu=x.cpu;
strcpy((p->data).qname,x.qname);
p->next=0;
if(q->front)
q->rear->next=p;
else
q->front=p;
q->rear=p;
}
/*删除队列q的队首进程，将其值赋给x并修改状态*/ void dequeue(PCB *x,Queue *q)
{
Node *p=(Node *)malloc(NODE_LEN);
if(is_empty(q))
return;
/*进入下一优先级队列之前修改状态*/
x->state='W';/*状态改为就绪*/
strcpy(x->qname,(q->front->data).qname);
/*已运行时间为上次已运行时间加上这次获得的cpu时间*/
x->runtime=(q->front->data).runtime+(q->front->data).cpu;
/*优先级减1，若该进程已是最低优先级，则将在主控过程中恢复*/ x->super=(q->front->data).super-1;
x->ndtime=(q->front->data).ndtime;
/*下次获得的时间片为这次的时间片加1*/
x->cpu=(q->front->data).cpu+1;
p=q->front;
q->front=q->front->next;
free(p);
}
/*主控过程*/
void main()
{
Queue *queue=NULL;/*设置就绪队列数组*/
Node *wait=(Node *)malloc(NODE_LEN);
PCB x;
int numberOFcourse,i,j,super,time;
int hight=0,num=0;
int temp_ndtime,temp_runtime,temp_cpu;
char name[20];
printf("\n请输入进程总个数?");
scanf("%d",&numberOFcourse);
/*为队列数组开辟空间，每个数组表示不同的优先级队列*/
queue=(Queue *)calloc(numberOFcourse,QUEUE_LEN);
/*输入各进程信息并初始化，并将其加入相应的优先级队列*/
for(i=0;i { printf("\n进程号NO.%d\n",i); printf("\n输入进程名："); scanf("%s",name); printf("\n输入进程优先数："); scanf("%d",&super); if(super>hight) hight=super; printf("\n输入进程运行时间："); scanf("%d",&time); strcpy(x.qname,name); x.state='W'; x.super=super; x.ndtime=time; x.runtime=0; x.cpu=1; enqueue(x,&queue[super-1]); } printf("\n\n"); /*进程调度过程*/ for(i=hight-1;i>=0;i--) { /*从最高优先级队列开始调度进程，直到该队列为空，则调度下一优先级队列*/ while(!is_empty(&queue[i])) { num++;/*调度次数*/ printf("按任一键继续......\n"); getch(); printf("The execute number:%d\n\n",num); /*打印正在运行进程*/ ((queue[i].front)->data).state='R'; printf("******当前工作的进程是：%s\n",((queue[i].front)->data).qname); printf("qname state super ndtime runtime\n"); printf("%s",((queue[i].front)->data).qname); printf("R"); printf("%d",(((queue[i].front)->data).super)); printf("%d",(((queue[i].front)->data).ndtime)); printf("%d\n\n",(((queue[i].front)->data).runtime)); /*计算一个进程运行一个时间片后，还需要运行的时间temp_time*/ temp_ndtime=((queue[i].front)->data).ndtime; temp_runtime=((queue[i].front)->data).runtime; temp_cpu=((queue[i].front)->data).cpu; temp_ndtime=temp_ndtime-temp_runtime-temp_cpu; /*若该进程已运行完毕*/ if(temp_ndtime<=0) { /*打印已完成信息，并将其删除出队列*/ printf("进程[%s]已完成\n\n",((queue[i].front)->data).qname); ((queue[i].front)->data).state='F'; dequeue(&x,&queue[i]); } /*若该进程未运行完毕*/ else { dequeue(&x,&queue[i]);/*将其删除出当前队列*/ /*若原优先级不是最低优先级，则插入下一优先级队列*/ if(i>0) enqueue(x,&queue[i-1]); /*若原优先级是最低优先级，则插入当前队列末尾*/ else { /*由于删除操作中将优先级减1，所以在此恢复*/ x.super=x.super+1; enqueue(x,&queue[i]); } } /*打印就绪队列状态*/ printf("******当前就绪队列状态为：\n"); for(j=i;j>=0;j--) { if(queue[j].front) { wait=queue[j].front; while(wait) { printf("qname state super ndtime runtime\n"); printf("%s",(wait->data).qname); printf("W"); printf("%d",(wait->data).super); printf("%d ",(wait->data).ndtime); printf("%d\n\n",((wait->data).runtime)); wait=wait->next; } } } printf("\n"); } } /*结束*/ printf("进程已经全部完成\n"); free(wait); free(queue); getch(); } 4.2先来先服务算法 4.2.1实验原理 先来先服务调度算法按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先分配处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件发生而不能继续运行时才释放处理机。 4.2.2参考代码 #include #include #include using namespace std; #define MAX 10 char process[MAX]=""; //进程名 int arrivetime[MAX];//达到时间 int servicetime[MAX];//服务时间 int finishtime[MAX]; //完成时间 int turnovertime[MAX];//周转时间 double avgturnovertime; //平均周转时间 double powertime[MAX]; //带权周转时间 double avgpowertime; //平均带权周转时间 int init(); void FCFS(); void output(); void showsingle(int* arr,int len); //初始化，并返回进程数 int init() { cout << "输入进程队列名(用单个字母表示一个进程,字母间用tab间隔)" << endl; int i=0; while(i { cin.get(process[i]); if(process[i]==' ' || process[i]=='/t') { continue; } if(process[i]=='q' || process[i]=='/n') { process[i]='/0'; break; } i++; } int len=strlen(process); cout << "依次输入进程到达时间(时间之间用tab间隔)" << endl; for(int ix=0; ix { cin >> arrivetime[ix]; } cout << "依次输入服务时间(时间之间用tab间隔)" < for(ix=0; ix { cin >> servicetime[ix]; } return len; } void FCFS(int len) { //完成时间的计算 for(int ix=0; ix { finishtime[ix]=accumulate(servicetime,servicetime+ix+1,0); } //周转时间计算 for(ix=0; ix { turnovertime[ix]=finishtime[ix]-arrivetime[ix]; } avgturnovertime=accumulate(turnovertime,turnovertime+len,0)*1.0/len; //带权周转时间计算 for(ix=0; ix { powertime[ix]=turnovertime[ix]*1.0/servicetime[ix]; } //平均带权周转时间 double tmptotal=0.0; for(ix=0; ix { tmptotal+=powertime[ix]; } avgpowertime=tmptotal/len; } void output() { cout < cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"< //显示进程序列 for(int ix=0; ix { cout < } cout << endl; //显示到达时间序列 showsingle(arrivetime,len); //显示服务时间序列 showsingle(servicetime,len); cout < showsingle(finishtime,len); //显示周转时间序列 showsingle(turnovertime,len); cout << "平均周转时间:" << avgturnovertime << endl; //显示带权周转时间序列 for(ix=0; ix { cout << powertime[ix] << "/t"; } cout < cout << "平均带权周转时间:" << avgpowertime << endl; cout <<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"< //对int类型的数组进行格式化输出 void showsingle(int* arr,int len) { for(int ix=0; ix { cout << arr[ix] << "/t"; } cout < } int main() { cout << "/t/t||本程序是先来先服务算法||" << endl; int len = init(); FCFS(len); output(); system("PAUSE"); return 0; } 5. 测试报告/实验报告 5.1最高优先数优先的调度算法5.1.1实验结果 【输入输出样例】 请输入进程总个数?4 进程号NO.0 输入进程名：aa 输入进程优先数：2 输入进程运行时间：2 进程号NO.1 输入进程名：vv 输入进程优先数：3 输入进程运行时间：2 进程号NO.2 输入进程名：rr 输入进程优先数：1 输入进程运行时间：3 进程号NO.3 输入进程名：kk 输入进程优先数：2 输入进程运行时间：1 按任一键继续...... The execute number:1 ******当前工作的进程是：vv qname state super ndtime runtime vv R 3 2 0 ******当前就绪队列状态为：qname state super ndtime runtime aa W 2 2 0 qname state super ndtime runtime kk W 2 1 0 qname state super ndtime runtime vv W 2 2 1 qname state super ndtime runtime rr W 1 3 0 按任一键继续...... The execute number:2 ******当前工作的进程是：aa qname state super ndtime runtime aa R 2 2 0 ******当前就绪队列状态为：qname state super ndtime runtime kk W 2 1 0 qname state super ndtime runtime vv W 2 2 1 qname state super ndtime runtime rr W 1 3 0 qname state super ndtime runtime aa W 1 2 1 按任一键继续...... The execute number:3 ******当前工作的进程是：kk qname state super ndtime runtime kk R 2 1 0 进程[kk]已完成 ******当前就绪队列状态为：qname state super ndtime runtime vv W 2 2 1 qname state super ndtime runtime rr W 1 3 0 qname state super ndtime runtime aa W 1 2 1 按任一键继续...... The execute number:4 ******当前工作的进程是：vv qname state super ndtime runtime vv R 2 2 1 进程[vv]已完成 ******当前就绪队列状态为：qname state super ndtime runtime rr W 1 3 0 qname state super ndtime runtime aa W 1 2 1 按任一键继续...... The execute number:5 ******当前工作的进程是：rr qname state super ndtime runtime rr R 1 3 0 ******当前就绪队列状态为：qname state super ndtime runtime aa W 1 2 1 qname state super ndtime runtime rr W 1 3 1 按任一键继续...... The execute number:6 ******当前工作的进程是：aa qname state super ndtime runtime aa R 1 2 1 进程[aa]已完成 ******当前就绪队列状态为： qname state super ndtime runtime rr W 1 3 1 按任一键继续...... The execute number:7 ******当前工作的进程是：rr qname state super ndtime runtime rr R 1 3 1 进程[rr]已完成 ******当前就绪队列状态为： 进程已经全部完成 5.1.2结果分析 本程序利用标准输入输出模拟了进程调度过程。输入各个进程的优先级和需要运行的时间等信息，输出给出了每进行一次调度的运行进程、就绪队列、以及各个进程的PCB信息，每当一个进程完成运行，输出该进程已完成的信息，最后当所有进程都完成后给出所有进程都完成的信息。 因为刚开始vv的优先级高，所以它先抢占CPU，运行一个时间单位后，vv的优先级数减少1，此时vv的优先级与aa、kk相等，但比rr大，所以vv排在就绪队列kk后面，aa处于运行状态；后面的也是这样分析。从而可以看出：刚开始优先数大的先运行，当进程运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），且此时有和它相等的优先数或比它大的优先数，则把它插入就绪队列等待CPU。 通过以上述数据测的最高优先数算法，可以看出这种算法的优点是可使资源利用率得以提高，公平性好，缺点是系统开销大，实现比较复杂。 5.2先来先服务算法 5.2.1实验结果 /*running result: ||本程序是先来先服务算法|| 输入进程队列名(用单个字母表示一个进程,字母间用tab间隔) a b c d e 依次输入进程到达时间(时间之间用tab间隔) 0 1 2 3 4 依次输入服务时间(时间之间用tab间隔) 4 3 5 2 4 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ a b c d e 0 1 2 3 4 4 3 5 2 4 4 7 12 14 18 4 6 10 11 14 平均周转时间:9 1 2 2 5.5 3.5 平均带权周转时间:2.8 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 请按任意键继续. . . */ 5.2.2结果分析 输入的a、b、c、d、e，是五个进程名；0、1、2、3、4为各个进程到达的时间；4、3、5、2、4是各个进程的占用CPU的时间；，当a进程结束时，b进程才是运行状态，以此类推，各个进程处于完成F（finish）状态的时间是4、7、12、14、18.，从而可以看出各个进程是按照进程进入就绪队列的先后顺序调度并分配处理机执行，先进入就绪队列的进程，先分配处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件发生而不能继续运行时才释放处理机。 但是，a进程运行时间是4，结束时间也是4；而d进程运行时间是2，结束时间是14，说明先来先服务有利于长作业进程，而不利于短作业进程。这是因为若一个长作业先到达系统，就会使许多短作业等待很长的时间，从而引起许多短作业用户的不满。有利于CUP繁忙的作业，不利于I/O繁忙的作 6. 课题研究结论 综上所述，本次课题通过采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法，对进程调度进行模拟实验，并分析实验数据，得到以下结论: 1、最高优先数优先的调度算法进入运行状态的依据是：优先数越大就先运行； 先来先服务算法进入运行状态的依据是：进入就绪队列的先后顺序，先进就先运行。 2、最高优先数优先的调度算法的调度方式是：抢占式和非抢占式；先来先服务算法的调度方式是：非抢占式。 3、最高优先数优先的调度算法的吞吐量高；先来先服务算法的吞吐量不突出。 4、最高优先数优先的调度算法的响应时间较好；先来先服务算法的响应时间不突出。 5、最高优先数优先的调度算法的系统开销大；先来先服务算法的系统开销小。 6、最高优先数优先的调度算法对进程作用：有利于紧迫作业；先来先服务算法对进程作用：有利于长作业（进程），不利于短作业，有利于CUP繁忙的作业，不利于I/O繁忙的作业 7. 总结 正文：本次课题主要研究了进程的调度算法即最高优先数优先的调度算法和先来先服务算法，并对进程调度进行模拟实验，对比分析两种算法的优缺点。根据实验可得：1.先来先服务算法比较有利于长作业（进程），而不利于短作业（进程）。因为短作业运行时间很短，如果让它等待较长时间才得到服务，那么，它的带权周转时间就会很高；先来先服务调度算法有利于CPU繁忙型的作业，不利于I/O繁忙型的作业，而目前大多数事务处理都属于I/O繁忙型作业。 2.优先级调度算法则保证了紧迫进程，而那些优先级较低的则可能长时间得不到调度；静态优先级调度算法简单易行，系统开销小，但是不太灵活，很可能出现低优先级的作业，长期得不到调度而等待的情况；静态优先级法仅适合于实现要求不太高的系统。动态优先级调度算法比较灵活科学，可防止有一些进程一直得不到调度，也可防止有些进程长期垄断处理机，但是需要花费相当多的执行程序时间，因而花费的系统开销比较大。 通过这次课程设计使我认识到自己在平时的学习中，只学到知识的表面，没有深入了解，当真正需要用到这些知识时，却不能系统的联系在一起。 课程设计报告 2015～2016学年第一学期 操作系统综合实践课程设计 实习类别课程设计 学生姓名李旋 专业软件工程 学号130521105 指导教师崔广才、祝勇 学院计算机科学技术学院 二〇一六年一月 - 1 - - 2 - 一、概述 一个目录文件是由目录项组成的。每个目录项包含16B，一个辅存磁盘块(512B)包含32个目录项。在目录项中，第1、2字节为相应文件的外存i节点号，是该文件的内部标识；后14B为文件名，是该文件的外部标识。所以，文件目录项记录了文件内、外部标识的对照关系。根据文件名可以找到辅存i节点号，由此便得到该文件的所有者、存取权、文件数据的地址健在等信息。UNIX 的存储介质以512B为单位划分为块，从0开始直到最大容量并顺序加以编号就成了一个文件卷，也叫文件系统。UNIX中的文件系统磁盘存储区分配图如下： 本次课程设计是要实现一个简单的模拟Linux文件系统。我们在内存中开辟一个虚拟磁盘空间(20MB)作为文件存储器，并将该虚拟文件系统保存到磁盘上(以一个文件的形式)，以便下次可以再将它恢复到内存的虚拟磁盘空间中。文件存储空间的管理可采用位示图方法。 二、设计的基本概念和原理 2.1 设计任务 多用户、多级目录结构文件系统的设计与实现。可以实现下列几条命令login 用户登录 logout 退出当前用户 dir 列文件目录 creat 创建文件 delete 删除文件 open 打开文件 close 关闭文件 - 3 - read 读文件 write 写文件 mkdir 创建目录 ch 改变文件目录 rd 删除目录树 format 格式化文件系统 Exit 退出文件系统 2.2设计要求 1) 多用户：usr1,usr2,usr3,……,usr8 (1-8个用户) 2) 多级目录：可有多级子目录； 3) 具有login (用户登录)4) 系统初始化（建文件卷、提供登录模块） 5) 文件的创建：create (用命令行来实现)6) 文件的打开：open 7) 文件的读：read8) 文件的写：write 9) 文件关闭：close10) 删除文件：delete 11) 创建目录（建立子目录）：mkdir12) 改变当前目录：cd 13) 列出文件目录：dir14) 退出：logout 新增加的功能： 15) 删除目录树：rd 16) 格式化文件系统：format 2.3算法的总体思想 - 4 - 课程设计任务书 一、课程设计目的 《计算机操作系统》课程设计是计算机类专业的集中实践性环节之一，是学习完《计算机操作系统》课程后进行的一次全面的综合练习。其目的在于加深对操作系统课程的理解，使学生更好地掌握操作系统的基本概念、基本原理、及基本功能，理解操作系统在计算机系统中的作用、地位和特点，具有分析实际操作系统，设计、构造和开发现代操作系统的基本能力，为今后从事的各种实际工作，如设计、分析和改进各种系统软件和应用软件提供必要的软件理论基础。 二、课程设计内容及要求 课程设计要求： 每位同学从下述设计任务中任选一个任务完成，上机验收运行结果，现场提问，并提交所完成该任务的课程设计报告。 实验要求： 1）上机前认真使用C语言编写好程序，采用Visual C++6.0作为编译环境； 2）上机时独立调试程序 3）上机验收运行结果，现场提问 4）根据具体任务要求，提交课程设计实验报告，报告内容包括：课程设计目的、内容、基本原理、模块划分、数据结构、算法设计、程序流程图（包括主程序流程图、模块详细设计流程图等）、以及算法源码（必须有相关注释，以有助于说明问题为宜，不得全盘打印而不加任何注释）、心得体会等。 设计内容一页式虚拟存储管理页面置换算法 1．目的和要求 在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础 2．实验内容 阅读教材《计算机操作系统》，掌握存储器管理相关概念和原理。 模拟实现页式虚拟存储管理的三种页面置换算法（OPT、FIFO和LRU），并通过比较性能得出结论。 前提： （1）页面分配采用固定分配局部置换。 （2）作业的页面走向和分得的物理块数预先指定。可以从键盘输入也可以从文件读入。 （3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。 3．实验环境 Windows操作系统、VC++6.0、C语言 4．实验提示 （1）基础知识 存储管理是操作系统进行资源管理的一个重要功能。现代操作系统广泛采用虚 Linux 系统课程设计报告 专业班级： 学号： 姓名： 同组成员： 2016年6月2日星期四 序论实验要求 实验目的 了解Linux内核源代码的目录结构及各目录的相关内容。 了解Linux内核各配置选项内容和作用。 掌握Linux内核配置文件的作用。 掌握Linux内核的编译过程。 掌握将新增内核代码加入到Linux内核结构中的方法。 实验指引 尽管目前Linux 2.6版本内核已经增加了很多对ARM体系甚至是S3C2440 CPU 的支持，但仍然需要对内核作一些小的修改来适应我们的开发板，并且需要重新配置、编译和重新生成新的内核映像。本实验从软硬件准备到下载到开发板等一系列连贯的操作来进行嵌入式Linux内核的移植。本实验的内核版本为2.6.29.1。 第一章Linux内核基础知识 1.1Linux版本 Linux主要的版本定义为“[主].[次].[发布].[修改]”的样式，次版本为奇数表示此版本为开发中版本，次版本为偶数表示此版本为稳定版本。 Linux内核的版本号可以从源代码的顶层目录下的Makefile中看到，比如2.6.29.1内核的Makefile中： VERSION = 2 PATCHLEVEL = 6 SUBLEVEL = 29 EXTRA VERSION = .1 其中的“VERSION”和“PATCHLEVEL”组成主版本号，比如 2.4、2.5、2.6等，稳定版本的德主版本号用偶数表示(比如2.6的内核)，开发中的版本号用奇数表示(比如2.5)，它是下一个稳定版本内核的前身。“SUBLEVEL”称为次版本号，它不分奇偶，顺序递增，每隔1~2个月发布一个稳定版本。“EXTRAVERSION”称为扩展版本号，它不分奇偶，顺序递增，每周发布几次扩展本版号。 1.2什么是标准内核 按照资料上的习惯说法，标准内核(或称基础内核)就是指主要在https://www.doczj.com/doc/1912647587.html,/维护和获取的内核，实际上它也有平台属性的。这些linux 中北大学 操作系统课程设计 说明书 学院、系：软件学院 专业：软件工程 学生姓名：徐春花学号： 设计题目：基于Linux的模拟文件系统的设计与实现 起迄日 期: 2014年6月14日- 2014年6月26日指导教薛海丽 师: 2014 年 6月 26 日 前言 简单地说，Linux是一套免费使用和自由传播的类Unix操作系统，它主要用于基于Intel x86系列CPU的计算机上。这个系统是由世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。 Linux不仅为用户提供了强大的操作系统功能，而且还提供了丰富的应用软件。用户不但可以从Internet上下载Linux及其源代码，而且还可以从Internet上下载许多Linux的应用程序。可以说，Linux本身包含的应用程序以及移植到Linux上的应用程序包罗万象，任何一位用户都能从有关Linux的网站上找到适合自己特殊需要的应用程序及其源代码，这样，用户就可以根据自己的需要下载源代码，以便修改和扩充操作系统或应用程序的功能。这对Windows NT、Windows98、MS-DOS或OS2 等商品化操作系统来说是无法做到的。 Linux具有：稳定、可靠、安全的优点，并且有强大的网络功能。其中有对读、 写进行权限控制、审计跟踪、核心授权等技术，这些都为安全提供了保障。在相关软 件的支持下，可实现WWW、FTP、DNS、DHCP、E-mail等服务，还可作为路由器 使用，利用IPCHAINSIPTABLE网络治理工具可构建NAT及功能全面的防火墙。 Linux是在GNU公共许可权限下免费获得的，是一个符合POSIX标准的操作系 统。Linux操作系统软件包不仅包括完整的Linux操作系统，而且还包括了文本编辑 器、高级语言编译器等应用软件。它还包括带有多个窗口管理器的X-Windows图形 用户界面，如同我们使用Windows NT一样，允许我们使用窗口、图标和菜单对系 统进行操作。 目录 1需求分析 (3) 1.1 功能介绍 (3) 1.2 目的及意义 (5) 1.2.1 目的 (5) 1.2.2 意义 (6) 1.3 设计成果 (7) 2总体设计 (8) 2.1功能介绍 (8) 2.2模块关联 (9) 3详细设计 (12) 操作系统课程设计要求 一．设计目的 熟悉Linux编程环境，加强对Linux命令的理解及函数的运用 二．设计内容 1. 在Linux环境下模拟实现简单命令解释器。 (1)要求实现的基本命令包括： pwd //显示当前所在目录的路径名 dir <目录名> //列出指定目录名中的所有目录及文件 cd <目录名或路径>//改变当前工作目录 newdir <目录名> //新建目录 deldir <目录名> //删除目录 exit //退出命令解释程序 (2)可选做的扩展命令包括： rename <旧文件名> <新文件名> //重命名一个文件或目录 find <目录> -name <待查找的文件名> //在指定的目录及其子目录中查找指定的文件date //显示当前日期 (3)提示：整个程序的大致框架可参考如下： while ( exit未被输入) { 接收键盘的一行输入 分析输入的命令 对输入的命令进行处理，调用系统函数实现功能 } 2. 设计要求 (1) 设计必须在Linux环境下进行。 (2) 命令解释程序的提示符为：姓名拼音@ (3) 程序编写中不得使用system()系统调用。 (4) 整个程序必须严格经过测试，完成所有基本功能。源程序应有较详尽的注释。 3.可能用到的系统调用： open(),close(),read(),write(),creat() chdir(), opendir(),readdir(),rewinddir(),closedir(),rmdir(),mkdir() getcwd(), ftw() time(), localtime(), asctime() 《Linux网络编程》 课程设计 班级： 姓名： 指导老师： 一、设计背景 Linux操作系统作为一个开源的操作系统被越来越多的人所应用，它的好处在于操作系统源代码的公开化！只要是基于GNU公约的软件你都可以任意使用并修改它的源代码。通过这次课程设计能更好的学习网络编程知识和掌握LINUX平台上应用程序设计开发的过程，将大学四年所学知识综合运用，为未来的工作学习打下基础。 二、设计目的 1、学习epoll 跟FTP被动模式 2、掌握linux基本命令，例如ls、cd、login； 3、学会如何编译、运行 三、环境要求 1、centos 64位操作系统 2、gcc编译器 四、设计原理 4．1客户端 客户端程序的主要任务有以下3个： （1）、分析用户输入的命令。 （2）、根据命令向服务器发出请求 （3）、接受服务器返回请求的结果 客户端为用户提供了3种命令：（1）、get:从服务器下载文件（2）、list:列出客户端当前目录的内容（3）、quit离开 4.2 服务器端 （1）、分析请求代码。 （2）、根据请求代码做相应的处理 （3）、等待返回结果或者应答信息 五、软件测试结果 六、部分主代码 #include "ftserve.h" int main(int argc, char *argv[]) { int sock_listen, sock_control, port, pid; if (argc != 2) { printf("usage: ./ftserve port\n"); exit(0); } port = atoi(argv[1]); // create socket if ((sock_listen = socket_create(port)) < 0 ) { perror("Error creating socket"); exit(1); } while(1) { // wait for client request 上海电力学院 计算机操作系统原理 课程设计报告 题目名称：编写程序模拟虚拟存储器管理 姓名：杜志豪.学号： 班级： 2012053班 . 同组姓名：孙嘉轶 课程设计时间：—— 评语： 成绩： 目录 一、设计内容及要求 (4) 1. 1 设计题目 (4) 1．2 使用算法分析： (4) 1． FIFO算法（先进先出淘汰算法） (4) 1． LRU算法（最久未使用淘汰算法） (5) 1. OPT算法（最佳淘汰算法） (5) 分工情况 (5) 二、详细设计 (6) 原理概述 (6) 主要数据结构(主要代码) (6) 算法流程图 (9) 主流程图 (9) Optimal算法流程图 (10) FIFO算法流程图 (10) LRU算法流程图 (11) ．1源程序文件名 (11) . 2执行文件名 (11) 三、实验结果与分析 (11) Optimal页面置换算法结果与分析 (11) FIFO页面置换算法结果与分析 (16) LRU页面置换算法结果与分析 (20) 四、设计创新点 (24) 五、设计与总结 (27) 六、代码附录 (27) 课程设计题目 一、设计内容及要求 编写程序模拟虚拟存储器管理。假设以M页的进程分配了N 块内存（N 课程设计说明书（操作系统） 题目：进程调度 院系：计算机科学与工程学院 专业班级：信息安全13-2 学号：20133029xx 学生姓名：xx 指导教师：xx 2015年12月15日 安徽理工大学课程设计（论文）任务书计算机科学与工程学院 安徽理工大学课程设计（论文）成绩评定表 摘要 现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。因而，进程就成为理解操作系统如何实现系统管理的最基本，也是最重要的概念。进程调度是进程管理过程的主要组成部分，是必然要发生的事件。 在现代操作系统中，进程的并发机制在绝大多数时候，会产生不断变化的进程就绪队列和阻塞队列。处于执行态的进程无论是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中，由进程调度选择一个进程进占CPU。 进程调度的核心是进程调度的算法．在本课程设计中，用良好清晰的界面向用户展示了进程调度中的时间片轮转调度算法。在最终实现的成果中，用户可指定需要模拟的进程数，CPU时间片和进程的最大执行时间，并且选择需要演示的算法，界面将会动态的显示进程调度过程及各个队列的变化。通过此进程调度模拟系统，用户可以对时间片轮转调度算法有进一步以及直观的了解。 关键词:进程，调度，PCB，时间片轮转 目录 1.设计目的 (6) 2.设计思路 (6) 3.设计过程 (8) 3.1流程图 (8) 3.2算法 (8) 3.3数据结构 (10) 3.4源代码 (10) 4.实验结果及分析 (20) 4.1 使用说明 (20) 4.2程序演示 (20) 5.实验总结 (24) 6.参考文献 (24) 《Linux课程设计》 设计题目：shell 编程实现用户信息管理专业：软件工程 指导教师：蔡照鹏王斌斌 班级： 学号： 姓名： 同组人： 计算机科学与工程学院 Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中。Linux是一个领先的操作系统，世界上运算最快的10台超级计算机运行的都是Linux操作系统。严格来讲，Linux这个词本身只表示Linux 内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。Linux得名于天才程序员林纳斯·托瓦兹。 Linux操作系统是UNIX操作系统的一种克隆系统，它诞生于1991 年的10 月5 日（这是第一次正式向外公布的时间）。以后借助于Internet网络，并通过全世界各地计算机爱好者的共同努力，已成为今天世界上使用最多的一种UNIX 类操作系统，并且使用人数还在迅猛增长。Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX 和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux 继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。 随堂练习提交截止时间：2017-12-15 23:59:59 当前页有10题，你已做10题，已提交10题，其中答对10题。 1.(单选题) 操作系统是基本的特征是（） A、并发 B、共享 C、虚拟 D、异步 答题： A. B. C. D. （已提交） 参考答案：A 问题解析： 2.(单选题) 下面不属于操作系统设计目标的是（） A、提高资源利用率 B、提高系统吞吐量 C、用户操作计算机更方便 D、并行执行多个进程 答题： A. B. C. D. （已提交） 参考答案：D 问题解析： 3.(单选题) 历史上最早出现的操作系统是（） A、单道批处理系统 B、多道批处理系统 C、分时系统 D、实时系统 答题： A. B. C. D. （已提交） 参考答案：A 问题解析： 4.(单选题) 实时操作系统必须在（）内处理完来自外部的事件。 A、响应时间 B、周转时间 C、被控对象规定时间 D、调度时间 答题： A. B. C. D. （已提交） 参考答案：C 问题解析： 5.(单选题) 操作系统是对（）进行管理的软件。 A、软件 B、硬件 C、计算机资源 D、应用程序 答题： A. B. C. D. （已提交） 参考答案：C 问题解析： 6.(单选题) 配置了操作系统的计算机是一台比原来的物理计算机功能更强的计算机,这样的一台计算机只是一台逻辑上的计算机,称为（）计算机。 A、并行 B、真实 C、虚拟 D、共享 答题： A. B. C. D. （已提交） 问题解析： 7.(单选题) 操作系统中采用多道程序设计技术提高了CPU和外部设备的（） A、利用率 B、可靠性 C、稳定性 D、兼容性 答题： A. B. C. D. （已提交） 参考答案：A 问题解析： 8.(单选题) 在操作系统中,并发性是指若干事件____发生( ) A、在同一时刻 B、在不同时刻 C、在某一时间间隔内 D、依次在不同时间间隔内 答题： A. B. C. D. （已提交） 参考答案：C 问题解析： 9.(单选题) （）操作系统允许在一台主机上同时联接多台终端,多个用户可以通过各自的终端同时交互地使用计算机。 A、网络操作系统 B、批处理操作系统 C、实时操作系统 D、分时操作系统 答题： A. B. C. D. （已提交） 参考答案：D 问题解析： 10.(单选题) 下面关于操作系统的叙述中正确的是 ( ) A、批处理作业必须提交作业控制信息 B、分时系统不一定都具有人机交互功能 C、从响应时间的角度看,实时系统与分时系统差不多 D、由于采用了分时技术,用户可以独占计算机的资源 答题： A. B. C. D. （已提交） 参考答案：A 问题解析： 河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9 1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法 学年论文（课程设计）题目：操作系统课程设计 学院数学与计算机学院 学科门类工学 专业网络工程 学号 姓名 指导教师王煜 年月日 河北大学学年论文（课程设计）任务书 （指导教师用表） 指导教师签字: 系主任签字： 主管教学院长签字： 装 订 线 河北大学学年论文（课程设计）成绩评定表学院：数学与计算机学院 装 订 线 摘要 此系统实现了存储管理、设备管理和进程管理。 存储管理部分主要实现主存空间的分配和回收。存储管理采用可移动的可变分区存储管理方式。采用数组来模拟主存，大小为512个字节。 设备管理主要包括设备的分配和回收。模拟系统中有A、B、C三种独占型设备，A设备3个，B设备2个，C设备1个。设备分配时采用采用先来先服务策略。设备回收时唤醒等待设备的进程。 进程管理主要包括进程调度，进程的创建和撤销、进程的阻塞和唤醒，中断作用的实现。其中硬件中的中央处理器用不断循环的函数CPU( )模拟，重要寄存器（如：程序状态寄存器PSW、指令寄存器IR）用全局变量模拟，中断的发现是在函数CPU中加检测PSW 的方式来模拟，时钟的模拟通过timer控件实现。进程控制块的模拟通过数组，本系统最多容纳10个。进程调度时采用时间片轮转调度算法，时间片为5。 关键词：存储管理设备管理进程管理时间片 ABSTRACT The system has storage management, equipment management and process management. The storage management has achieved the allocation and recovery of the main memory space. Variable storage management is used as storage management .We simulate the main memory by array, whose size is 512 bytes. The device management, including the distribution and recovery of devicet. We simulate three devices ,A,B,C. the numbers of them are 3,2,1. The distribution of device used to adopt first-come first-service strategy. It awakes the blocking process when the device is recycled. The process management, including scheduling ,creating revocation ,blocking and waking up the process, the realization of the interruption.We simulate the central processing unit by the cycling function named CPU(),simulate the important register by global variable, simulate the recovering of interruption by checking PSW in the function of CPU(),simulate the clock by the timer control. The simulation of the process control block by array, whose number is up to 10. When the scheduling of the process happens, we use the algorithm of time piece rotation scheduling, and the time piece is 5. Key words: storage device process time 《Linux课程设计》 设计题目： shell 编程实现用户信息管理专业：软件工程 指导教师：蔡照鹏王斌斌 班级： 学号： 姓名： 同组人： 计算机科学与工程学院 Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux版本，但它们都使用了Linux核。Linux可安装在各种计算机硬件设备中。Linux是一个领先的操作系统，世界上运算最快的10台超级计算机运行的都是Linux操作系统。严格来讲，Linux这个词本身只表示Linux核，但实际上人们已经习惯了用Linux来形容整个基于Linux核，并且使用GNU 工程各种工具和数据库的操作系统。Linux得名于天才程序员林纳斯·托瓦兹。 Linux操作系统是UNIX操作系统的一种克隆系统，它诞生于1991 年的10 月5 日（这是第一次正式向外公布的时间）。以后借助于Internet 网络，并通过全世界各地计算机爱好者的共同努力，已成为今天世界上使用最多的一种UNIX 类操作系统，并且使用人数还在迅猛增长。 Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix 以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的制约的、全世界都能自由使用的Unix兼容产品。 Linux课程设计---编写proc文件系统相关的内核模块 学号：20085229 姓名：杜森 班级：08级网络一班 指导教师：于群 日期：2011年6月29号 一、背景知识： 1、内核模块。 操作系统采用两种体系结构：微内核（Micro kernel），最常用的功能模块被设计成内核模式运行的一个或一组进程，而其它大部分不十分重要的功能模块都作为单独的进程在用户模式下运行！单内核（Monolithic kernel，有时也叫宏内核Macro kernel）！内核一般作为一个大进程的方式存在。该进程内部又可以被分为若干模块，在运行的时候，它是一个独立的二进制映象为了弥补单一体系结构的这一缺陷，Linux操作系统使用了模块机制。用户可以根据需要，在不需要对内核重新编译的情况下，模块可以动态地载入内核或从内核中移出！如图所示，模块可通过 insmod命令插入内核，也可以通过rmmod命令从内核中删除。 2、进程管理 Linux的每一个进程都有自己的属性，用一个task struct数据结构表示，即进程控制块Ⅲ(Process Concrol Block，PCB)。它对进程在其生命周期内涉及的所有事件进行全面的描述，主要有进程标识符(PID)、进程状态信息、进程调度信息、进程所占的内存区域、相关文件的文件描述符、处理器环境信息、信号处理、Linux操作系统内核分析与研究资源安排、同步处理等几个方面。在一个系统中，通常可拥有数百个甚至数千个进程，相应地就有很多进程控 制块。为了有效地对它们加以管理，应该用适当地方式将这些进程控制块组织起来。 进程控制块数据结构主要域定义如下： task_struct结构：在linux/sched.h中 struct task_struct{ volatile long state; //系统进程状态，一共有五种状态： //0 可运行态 //1 可中断的等待态 //2 不可中断的等待态 //3 僵死态 南通大学计算机科学与技术学院操作系统课程设计报告 专业： 学生姓名： 学号： 时间： 操作系统模拟算法课程设计报告 设计要求 将本学期三次的实验集成实现： A.处理机管理； B.存储器管理； C.虚拟存储器的缺页调度。 设计流程图 主流程图 开始的图形界面 处理机管理存储器管理缺页调度 先来先服务时 间 片 轮 转 首 次 适 应 法 最 佳 适 应 法 先 进 先 出 L R U 算 法 A.处理机调度 1)先来先服务FCFS N Y 先来先服务算法流程 开始 初始化进程控制块，让进程控制块按进程到达先后顺序让进程排队 调度数组中首个进程，并让数组中的下一位移到首位 计算并打印进程的完成时刻、周转时间、带权周转时间 其中：周转时间 = 完成时间 - 到达时间 带权周转时间=周转时间/服务时间 更改计时器的当前时间,即下一刻进程的开始时间 当前时间=前一进程的完成时间+其服务时间 数组为空 结束 2)时间片轮转法 开始 输入进程总数 指针所指的进程是 否结束 输入各进程信息 输出为就绪状态的进程的信息 更改正在运行的进程的已运行时间 跳过已结束的程序 结束 N 指向下一个进程 Y 如果存在下一个进程的话 Y N 输出此时为就绪状态的进程的信息 时间片轮转算法流程图 B.存储器管理(可变式分区管理） 1)首次适应法 分配流程图 申请xkb内存 由链头找到第一个空闲区 分区大小≥xkb？ 大于 分区大小=分区大小-xkb，修改下一个空闲区的后向指针内容为（后向指针）+xkb;修改上一个空闲区的前向指针为（前向指针）+xkb 将该空闲区从链中摘除：修改下一个空闲区的后向地址=该空闲区后向地址，修改上一个空闲区的前向指针为该空闲区的前向指针 等于 小于延链查找下 一个空闲区 到链尾 了？ 作业等待 返回是 否 登记已分配表 返回分配给进程的内存首地址 开始 实验一进程调度 一、实验目的 观察、体会Linux 系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程调度算法，进程切换的理解。 二、实验内容 采用动态优先数的方法，编写一进程调度程序模拟程序。模拟程序只进行相应的调度模拟操作，不需要实际程序。 [提示]： (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为： 进程名 指针 要求运行时间 优先数 状态 其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。 指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。 要求运行时间——假设进程需要运行的单位时间数。 优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。 状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。 (3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。 (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行： 优先数-1 要求运行时间-1 来模拟进程的一次运行。 提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。 (5) 进程运行一次后，若要求运行时间?0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。 (6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤， 一、课程设计目的 Linux 系统的开源性使其在嵌入式系统的开发中得到了越来越广泛的应用，但其本身并没有对种类繁多的硬件设备都提供现成的驱动程序，特别是由于工程应用中的灵活性，其驱动程序更是难以统一，这时就需开发一套适合于自己产品的设备驱动。对用户而言，设备驱动程序隐藏了设备的具体细节，对各种不同设备提供了一致的接口，一般来说是把设备映射为一个特殊的设备文件，用户程序可以像对其它文件一样对此设备文件进行操作。 通过这次课程设计可以了解linux的模块机制，懂得如何加载模块和卸载模块，进一步熟悉模块的相关操作。加深对驱动程序定义和设计的了解，了解linux驱动的编写过程，提高自己的动手能力。 二、课程设计内容与要求 字符设备驱动程序 1、设计目的：掌握设备驱动程序的编写、编译和装载、卸载方法，了解设备文件的创建，并知道如何编写测试程序测试自己的驱动程序是否能够正常工作 2、设计要求： 1) 编写一个简单的字符设备驱动程序，该字符设备包括打开、读、写、I\O控制与释放五个基本操作。 2) 编写一个测试程序，测试字符设备驱动程序的正确性。 3) 要求在实验报告中列出Linux内核的版本与内核模块加载过程。 三、系统分析与设计 1、系统分析 系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能: 1、对设备初始化和释放； 2、把数据从内核传送到硬件和从硬件读取数据； 3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据； 4、检测和处理设备出现的错误。 字符设备提供给应用程序的是一个流控制接口，主要包括op e n、clo s e（或r ele as e）、r e ad、w r i t e、i o c t l、p o l l和m m a p等。在系统中添加一个字符设备驱动程序，实际上就是给上述操作添加对应的代码。对于字符设备和块设备，L i n u x内核对这些操作进行了统一的抽象，把它们定义在结构体fi le_operations中。 2、系统设计： 、模块设计： 广西大学计算机与电子信息学院 课程设计报告 ( 2015——2016年度第一学期) 名称： UNIX程序设计课程设计 题目： UNIX程序设计课程设计 院系：计算机与电子信息学院 班级：计科132班 学号： 58 学生姓名：郭江达 指导教师：葛志辉 设计周数： 2周 成绩： 日期： 2015年 12月 27日 目录 1. 设计任务 (1) 2. 设计步骤 (1) 开发环境配置 (1) 开发工具 (2) 3. 程序开发步骤 (4) 4. 遇到的问题及相应解决办法 (12) 5. 个人体会及建议 (13) 参考文献 (13) 1. 设计任务 设计题目、任务及完成情况的大致说明，让老师能够了解你所做工作的大体情况。（每个人都要独立完成下面三个题目，不要相互抄袭！切记！） 1、完成Linux下的shell编程，要利用shell编程实现某一个具体的功能。 2、完成Linux下的C语言编程，要求至少包括两个文件，比如一个,，中包含了中的声明，分别利用gcc和makefile进行编译。 3、完成Linux下PHP+MySQL的编程，能够完成一个简单的具有数据库存储功能的网站。 2. 设计步骤 开发环境配置 Shell编程的开发环境 Shell编程的开发环境不需要什么配置，只需在Linux系统的终端进行即可。 C语言编程的开发环境 C语言在Linux系统下编程，需要dev安装包，用于编译C语言。 在终端下输入“sudo apt-get install libc6-dev”进行下载，在下载之前需要输入登录密码，之前已经下载好了，如下图所示： 下载好后，系统会自动安装，安装完成便可在终端编译C语言程序了。 Linux下PHP+MySQL编程的开发环境 这是在ubuntu上搭建LAMP，需要安装“php5”，“mysql”，“apache2”和“phpmyadmin”，如下图所示： 开发工具 VMware Workstation 12 虚拟机 VMware Workstation 12 虚拟机简介：著名的虚拟机软件。不需要分区或重开机就能在同一台PC上使用两种以上的操作系统，完全隔离并且保护不同OS的操作环境以及所有安装在OS上面的应用软件和资料，不同的OS之间还能互动操作，包括网络、周边、文件分享以及复制贴上功能等。 安装方法： 1.下载虚拟机可执行文件点击运行，按照安装教程安装即可。 使用方法： 打开虚拟机，在“文件”菜单中选择“新建虚拟机”，然后弹出“新建虚拟机 计算机操作系统课程设计 班级：计091-1 姓名： 学号： 使用语言：C++ 指导老师： 学院： 一、系统要求 1、实验目的 通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现。 2、实验内容 为linux系统设计一个简单的二级文件系统。要求做到以下几点： （1）可以实现下列几条命令（至少4条）； login 用户登陆 dir 列文件目录 create 创建文件 delete 删除文件 open 打开文件 close 关闭文件 read 读文件 write 写文件 （2）列目录时要列出文件名、物理地址、保护码和文件长度； （3）源文件可以进行读写保护。 二、系统分析 1、设计思想 本文件为二级文件系统，即要实现对文件的增删改查，同时又具备登陆系统、注册用户的功能，各个用户之间的文件系统互不干扰。 本文件系统采用两级目录，其中第一级对应于用户账号，第二级对应于用户帐号下的文件。另外，为了简便文件系统未考虑文件共享，文件系统安全以及管道文件与设备文件等特殊内容。 系统采用结构体来存储用户、文件目录、文件数据内容： 0 48*5 48*5+44*50 48*5+44*50+264*200 每个分区都是由结构体组成，每个个去的结构体的个数由格式化系统是决定。 整个系统的编码构成主要分为： Allstruct.h 定义了每个分区的结构体； Mysys.h 声明了对系统操作的各种方法；Myuserfile.h 声明了对文件操作的各种方法； Mymain.cpp 整个系统的主函数，操作入口； Mysys.cpp 包含了mysys.h，实现了操作系统的各种方法；Myuserfile.cpp 包含了myuserfile.h，实现了操作文件的各种方法； 2、主要数据结构 Allstruct.h文件的内容： struct s_user //用户区结构体 { long isuse; //是否使用 char name[20]; //用户名 char psd[20]; //密码 long address; //目录地址 }; 题目一模拟操作系统设计 设计一个模拟操作系统管理程序，实现下列管理功能： 1．内存管理功能 2．文件管理功能 3．磁盘管理功能 题目二 虚拟存储器各页面置换算法的实现与比较 内容：设计一个虚拟存储区和内存工作区，通过产生一个随机数的方法得到一个页面序列，假设内存给定的页面数由键盘输入，分别计算使用下述各方法时的内存命中率： 先进先出算法（FIFO）、最近最少使用算法（LRU）、最佳淘汰算法（OPT）、最少访问页面算法（LFU）等。 题目三文件系统设计 通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现。 内容：为Linux系统设计一个简单的二级文件系统，以实现下列功能： 1．可以实现下列几条命令 （1）login 用户登录 （2）dir 文件目录列表 （3）creat 创建文件 （4）delete 删除文件 （5）open 打开文件 （6）close 关闭文件 （7）read 读文件 （8）write 写文件 2．实验提示 （1）首先确定文件系统的数据结构：主目录、子目录及活动文件等。主目录和子目录都以文件的形式存放在磁盘，这样便于查找和修改。 （2）用户创建的文件，可以编号存储于磁盘上。如file0、file1、file2……等，并以编号作为物理地址，在目录中进行登记。 [清华大学《操作系统教程》X丽芬编著 题目四设计一个按时间片轮转法进程CPU调度的程序。 提示： （1）假设系统有5个进程，每个进程用一个进程控制块PCB来代表，PCB中包含进程名、指针、到达时间、估计运行时间、进程状态表。其中，进程名即为进程进标识。 （2）为每一个进程设计一个要示运行时间和到达时间。 （3）按照进程到达的先后顺序排成一个循环队列，再设一个队首指针指向第一个到达的进程首址。 （4）执行处理机调度时，开始选择队首的第一个进程运行。另外再设一个当前运行进程指针，指向当前正运行的进程。 （5）由于本实验是模拟实验，所以对被选中进程并不实际启运运行，只是执行： a.估计驼行时间减1 b.输出当前运行进程的名字。 用这两个操作来模拟进程的一次运行。 （6）进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的指针所指进程，以指示应运行进程。同时还尖判断该进程的剩八运行时间是否为零。若不为零，则等待下一轮的运行；若该进程的剩余运行时间为零，则将该进程的状态置为完成态C，并退出循环队列。 （7）若就绪队列不空，则重复上述的（%）和（6）步，直到所有进程都运行完为止。 （9）在所设计的调度程序中，应包含显示或打印语句，以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。 题目5 设计一个按先来先服务调度的算法 题目5 设计一个按优先级调度的算法 题目6 设计一个用银行家算法进程资源分配的程序 题目7 模拟内存管理，实现内存块的分配与回收。 内存管理方法可以取以下之一： （1）可变分区 （2）页式存储管理 内存分配算法可以取以下之一： （1）首次适应算法 （2）最佳适应算法 题目8 设计一个SPOOLING假脱机输出的模拟程序 题目9 模拟设计MS-DOS操作系统中磁盘文件的存储结构 题目10 模拟设计Linux操作系统中磁盘文件的存储结构操作系统课程设计
操作系统课程设计题目
Linux 系统课程设计报告
(完整版)操作系统毕业课程设计说明书-基于Linux的模拟文件系统的设计与实现
《操作系统课程设计》题目要求
linux网络编程课设报告
操作系统课程设计报告
操作系统-课程设计
Linux课程设计报告
2017操作系统(含课程设计) - 随堂练习
2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序
操作系统课程设计论文
Linux课程设计报告
Linux课程设计
操作系统(一个小型操作系统的设计与实现)课程设计
操作系统课程设计题目
linux字符设备驱动课程设计报告
Linux设计报告
计算机操作系统课程设计
操作系统课程设计报告题目及代码
相关主题
文本预览