操作系统文件课程设计
⑴ “计算机操作系统”课程设计
你要出书吗？？
http://download.chinaitlab.com/system/files/11363.html
http://download.csdn.net/source/308961
http://www.ccworker.com/html/dianzishuxiazai/xitongwangluo/200806/02-7752.html
http://www.eshuba.com/soft/6065.htm
⑵ 操作系统课程设计报告
题 目 : [课程设计] 操作系统课程设计报告
尺 寸 : 操作系统课程设计_进程调度.doc
目 录 : 不存在
原 文 : 通过大三第一学期的操作系统学习，我们对操作系统的基本概念，原理及实现技术都有了一定的了解，也为我们这次的课程设计做好了理论上的准备。通过学习与交流我们这次在李长悦老师的带领下进行了为期一周的课程设计。为我们更好的巩固已学习的知识及培养我们的动手能力创造了良好的机会。
这次课程设计主要是进行进程调度的虚拟实现，在课程设计以前李老师就把调度原则告诉了我们：
一 进程调度
1．调度原则
采用动态优先数调度与时间片相结合的调度算法。首先从就绪队列（按优先数从高到低排列）中选取一个将要投入运行的进程，投入运行1秒钟（至多一秒钟。以一秒钟作为时间片），若在规定的时间片内进程未完成运行，则让出CPU，该进程的运行时间减1，并按下列优先数重新确定进程的优先数，即：
新优先数=原优先数*0.8+10/剩余时间
接着将该进程重新插入就绪队列，重新从就绪队列选取下一个合适的进程再投入运行。
2．进程数据结构
关键词 : 课程设计 操作系统 进程调度 实习报告
⑶ 求操作系统课设c语言编写的
下面的程序假设你的当前目录有一个helloworld程序, 这个你会写吧? :)
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
int pid;
int status;
pid = fork();
if (pid == 0) {
/* child process */
execve("./helloworld", NULL, NULL);
} else if (pid < 0) {
/* failed to fork, print error message */
printf("fork error, errno = %d\n", errno);
} else {
waitpid(pid,&status,0)
}
return 0;
}
⑷ 操作系统课程设计：Nachos的文件管理模块升级
这是我们做的、基本上满足你的要求
#pragma warning(disable:4786)
#include <iostream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
struct File
{
string name;
bool isDir;
int pos;
int len;
File* pPre;
File* pNxt;
File* pChd;
File* pPar;
File(){name = "";isDir = false;pos = len = 0;pChd = pPar = pPre = pNxt = NULL;}
};
class DirSystem
{
private:
File* pRoot;
public:
DirSystem(){pRoot = new File;pRoot->pChd = new File;pRoot->pPar = pRoot;}
File* Append(File*& tail,const File& f)
{
tail->pNxt = new File;
tail->pNxt->isDir = f.isDir;
tail->pNxt->len = f.len;
tail->pNxt->pos = f.pos;
tail->pNxt->name = f.name;
tail->pNxt->pChd = tail->pNxt->pNxt = tail->pNxt->pPar = NULL;
tail->pNxt->pPre = tail;
return tail->pNxt;
}
void Md(File*& pCur,const File& f)
{
if(pCur->pChd == NULL)
{
pCur->pChd = new File;
pCur->pChd->pPar = pCur;
Append(pCur->pChd,f);
}
else
{
File* tmp = pCur->pChd;
while(tmp->pNxt != NULL)
tmp = tmp->pNxt;
Append(tmp,f);
}
}
void Show(File* pF)
{
if(pF == NULL)
return;
File* cur = pF->pNxt;
while(cur != NULL)
{
cout << cur->name;
if(cur->isDir)
cout << "(文件夹) " << endl;
else
cout << "(文件) " << endl;
cur = cur->pNxt;
}
}
void Rd(File* pF)
{
if(pF == NULL)
cout << "文件不存在!" << endl;
else if(pF->pChd != NULL)
cout << "该文件夹中还有其它文件，拒绝删除!" << endl;
else
{
pF->pPre->pNxt = pF->pNxt;
if(pF->pNxt != NULL)
pF->pNxt->pPre = pF->pPre;
delete pF;
}
}
void Init()
{
int num;
cout << "输入分区数:" << endl;
cin >> num;
int i,pos;
File f,*t;
pos = 0;
t = pRoot->pChd;
f.isDir = true;
f.pChd = f.pNxt = f.pPar = f.pPre = NULL;
char ch = 'C';
for(i = 0;i < num;++i)
{
cout << "输入分区容量:" << endl;
cin >> f.len;
f.pos = pos;
pos += f.len;
f.name = ch++ + string(":");
t = Append(t,f);
}
}
void Run()
{
File* pCur;
pCur = pRoot->pChd->pNxt;
string hint,cmd,tmp;
hint = pCur->name + "\\>";
while(true)
{
cout << hint;
cin >> cmd;
cmd = Uniform(cmd);
if(cmd == "DIR")
{
cout << pCur->name << endl;
Show(pCur->pChd);
}
else if(cmd == "CD")
{
cin >> cmd;
cmd = Uniform(cmd);
File* ftmp = pCur;
string htmp = hint;
hint = "";
pCur = pRoot;
bool find = false;
vector<string> nm = Parse(cmd);
for(int i = 0;i < nm.size();++i)
{
find = false;
pCur = pCur->pChd->pNxt;
while(pCur != NULL)
{
if(pCur->name == nm[i])
{
hint += nm[i] + '\\';
find = true;
break;
}
pCur = pCur->pNxt;
}
if(!find)
break;
}
if(!find)
{
pCur = ftmp;
hint = htmp;
cout << "没有找到要转向的路径!" << endl;
}
else
{
if(nm.size() > 1)
hint.erase(hint.end()-1);
hint += ">";
}
}
else if(cmd == "MD")
{
cin >> cmd;
File f;
f.isDir = true;
f.pos = 0;
f.len = 100;
f.name = cmd;
f.pChd = f.pPar = f.pNxt = f.pPre = NULL;
Md(pCur,f);
}
else if(cmd == "MF")
{
cin >> cmd;
File f;
f.isDir = false;
f.pos = 0;
f.len = 100;
f.name = cmd;
f.pChd = f.pPar = f.pNxt = f.pPre = NULL;
Md(pCur,f);
}
else if(cmd == "RD")
{
cin >> cmd;
File* tar = pCur->pChd;
while(tar)
{
if(tar->name != cmd)
tar = tar->pNxt;
else
break;
}
Rd(tar);
}
else
{
cout << "您输入的命令本系统不识别!" << endl;
}
}
}
private:
vector<string> Parse(string tar)
{
vector<string> res;
int beg,end;
beg = 0;
end = tar.find('\\',beg);
while(true)
{
res.push_back(tar.substr(beg,end - beg));
if(end == -1)
break;
beg = end + 1;
end = tar.find('\\',beg);
}
return res;
}
string Uniform(string cmd)
{
string res = cmd;
int offset = 'A' - 'a';
for(int i = 0;i < cmd.size();++i)
{
if(cmd[i] >= 'a' && cmd[i] <= 'z')
res[i] = cmd[i] + offset;
}
return res;
}
};
int main()
{
DirSystem ds;
ds.Init();
ds.Run();
return 0;
}
⑸ 操作系统课程设计
完整的设计报告和应用程序，已经发你邮箱了！
⑹ 操作系统课程设计----文件系统设计
就是SADAW架上额啊福娃我再减去二期 2 去
⑺ 操作系统课程设计
设计题目
1设计题目：CPU调度(CPU调度算法的模拟实现)
具体内容：编写算法，实现CPU调度算法FCFS、非抢占SJF、可抢占优先权调度、RR
针对模拟进程，利用CPU调度算法进行调度
进行算法评价，计算平均周转时间和平均等待时间
要求：调度所需的进程参数由输入产生
手工输入
随机数产生
输出调度结果
输出鸡掸惯赶甙非轨石憨将算法评价指标
2设计题目：虚拟内存 (页面置换算法的模拟实现)
具体内容：编写算法，实现页面置换算法FIFO、LRU
针对内存地址引用串，运行页面置换算法进行页面置换
要求：算法所需的引用串参数由输入产生：可由手工输入也可基于随机数产生
输出内存驻留的页面集合
1．进程调度算法模块
[问题描述]
1、进程调度算法：采用动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。
2、每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：
进程名---进程标示数 ID
优先数 PRIORITY 优先数越大优先权越高
到达时间---进程的到达时间为进程输入的时间。、
进程还需要运行时间ALLTIME，进程运行完毕ALLTIME=0，
已用CPU时间----CPUTIME、
进程的阻塞时间STARTBLOCK-表示当进程在运行STARTBLOCK个时间片后，进程将进入阻塞状态
进程的阻塞时间BLOCKTIME--表示当进程阻塞BLOCKTIME个时间片后，进程将进入就绪状态
进程状态—STATE
队列指针NEXT 用来将PCB排成队列。
3、调度原则：
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
进程在就绪队列中待一个时间片，优先数加1
每个进程的状态可以是就绪 R（READY）、运行R（Run）阻塞B(BLOCK)、或完成F（Finish）四种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减3，然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
求课程设计报告和用c语言编写的源代码
⑻ 求一个操作系统课程设计
#include<iostream>
using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*进程名称*/
int number; /*进程编号*/
float come_time; /*到达时间*/
float run_begin_time; /*开始运行时间*/
float run_time; /*运行时间*/
float run_end_time; /*运行结束时间*/
int priority; /*优先级*/
int order; /*运行次序*/
int run_flag; /*调度标志*/
}tasks[MAX];
int counter; /*实际进程个数*/
int fcfs(); /*先来先服务*/
int ps(); /*优先级调度*/
int sjf(); /*短作业优先*/
int hrrn(); /*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/
void main()
{ int option;
pinput();
printf("请选择调度算法（0~4）:\n");
printf("1.先来先服务\n");
printf("2.优先级调度\n");
printf(" 3.短作业优先\n");
printf(" 4.响应比高优先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{ case 0:
printf("运行结束。\n");
break;
case 1:
printf("对进程按先来先服务调度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("对进程按优先级调度。\n\n");
ps();
poutput();
break;
case 3:
printf("对进程按短作业优先调度。\n\n");
sjf();
poutput();
break;
case 4:
printf("对进程按响应比高优先调度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先来先服务*/
{
float time_temp=0;
int i;
int number_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}
int ps() /*优先级调度*/
{
float temp_time=0;
int i=0,j;
int number_schel,temp_counter;
int max_priority;
max_priority=tasks[i].priority;
j=1;
while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{ if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int sjf() /*短作业优先*/
{
float temp_time=0;
int i=0,j;
int number_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
}
for(j=0;j<counter;j++)
{ if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}
int hrrn() /*响应比高优先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一个进程被调度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*调度其他进程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{ respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找响应比高的进程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*进程参数输入*/
{ int i;
printf("please input the process counter:\n");
scanf("%d",&counter);
for(i=0;i<counter;i++)
{ printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*调度结果输出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_time run_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d, %5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}
如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！
⑼ 操作系统课程设计 （包括进程管理、进程的同步和互斥、存储管理）
一、实验的目的与基本要求实验目的本课程设计是为了配合操作系统课程的理论教学而设置的，目的是通过课程设计的综合训练，加强学生对操作系统概念的实际应用技能的训练，提高学生分析问题和解决问题的能力。基本要求课程设计按照教学要求需要两周时间完成，两周中每天（按每周5天）至少要上3-4小时的机来调试程序。学生要发挥自主学习的能力，充分利用时间，安排好课设的时间计划，并在课设过程中不断检测自己的计划完成情况，及时的向教师汇报。课程设计的具体内容如下：设计1 进程管理1. 设计目的加深对进程概念的理解，明确进程和程序的区别；进一步认识并发执行的实质；实现Linux中进程通信的两种方式：软中断和管道通信。2. 设计内容1) 进程的创建和控制编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。每个进程在屏幕上显示一个字符，记录屏幕上的显示结果，并分析原因。修改以编写的程序，将每个进程输出一个字符改为每个进程输出一句话。2) 进程的软中断通信使用系统调用fork()创建两个子进程，使用系统调用signal（）让父进程捕捉用alarm函数设置时钟的时间段终止时产生的信号，当捕捉到该信号后，父进程使用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出子进程被杀死信息后终止，父进程等待两个子进程终止后，输出父进程被杀死信息后终止程序。记录屏幕上的显示结果，并分析原因。3) 进程的管道通信使用系统调用pipe()建立一个管道；两个子进程分别向管道写信息，父进程则从管道读出来自子进程的信息，显示在屏幕上。记录屏幕上的显示结果，并分析原因。3. 系统调用函数说明、参数值及定义1. Fork()创建一个新进程进程int fork()其中返回int取值意义如下：正确返回：在父进程中返回子进程的进程号，在子进程中返回0错误返回：-12. Lockf(int files,int function,long size)用作锁定文件的某些段或者整个文件。file：文件描述符；function：锁定和解锁，1表示锁定，0表示解锁；size：是锁定或解锁的字节数，若用0，表示从文件的当前位置到文件尾。3. Signal(int sig, (*func) function)进程控制软中断信号的处理。signal()会依照参数sig指定的信号编号来设置该信号的处理函数。sig： SIGALRM: alarm()函数设置的时钟的时间段终止时产生的信号.其它信号略function：信号处理的一个函数地址。4. kill(int pid,int sig)向一个进程或一个进程组发信号，可以用来送参数sig指定的信号给参数pid指定的进程。pid: pid>0 将信号传给进程号为pid的进程其它略signumber: 送给进程号为pid进程指定信号量5. alarm(unsigned int seconds)设置一个指定时间的计时器seconds: 设置时间秒数6. int pipe(int filedes[2])filedes为整数数组名,在调用这个函数后,系统为通道分配的两个文件描述符将通过这个数组返回到用户进程中, filedes[1]是文件输出描述符, filedes[0]是文件输入描述符7. int wait(int *status)暂停目前进程的执行，直到有信号到来或子进程的结束。子进程的结束状态指会由参数status返回，如果不在意结束状态时，则参数status可以设置成NULL设计2 进程的同步与互斥1. 设计目的分析进程争用资源的现象，学习解决进程互斥的方法。2. 设计内容用程序实现生产者-消费者问题l 问题描述： 一个仓库可以存放K件物品。生产者每生产一件产品，将产品放入仓库，仓库满了就停止生产。消费者每次从仓库中去一件物品，然后进行消费，仓库空时就停止消费。l 数据结构：进程：Procer - 生产者进程，Consumer - 消费者进程 buffer: array [0..k-1] of integer; in,out: 0..k-1; in记录第一个空缓冲区，out记录第一个不空的缓冲区 s1,s2,mutex: semaphore; s1控制缓冲区不满,s2控制缓冲区不空,mutex保护临界区； 初始化s1=k,s2=0,mutex=1l 原语描述procer（生产者进程）： Item_Type item;{while (true){proce(&item);p(s1);p(mutex);buffer[in]:=item; in:=(in+1) mod k;v(mutex);v(s2);}}consumer（消费者进程）： out:=(out+1) mod k;v(mutex);v(s1);}}设计3 存储管理1. 设计目的通过请求页式存储管理中页面置换算法设计，了解存储技术的特点，掌握请求页式存储管理的页面置换算法。2. 设计内容l 将指令序列转换为用户虚存中的请求调用页面流。i. 页面大小为1Kii. 用户内存容量为4页到40页iii. 用户外存的容量为40k在用户外存中，按每K存放10条指令，400条指令在外存中的存放方式为：0-9条指令为第0页10-19条指令为第1页。390-399条指令为第39页按以上方式，用户指令可组成40页l 通过随机数产生一个指令序列，共400个指令（0-399）l 模拟请求页式存储管理中页面置换算法执行一条指令，首先在外存中查找所对应的页面和页面号，然后将此页面调入内存中，模拟并计算下列各述算法在不同内存容量下的命中率(页面有效次数/页面流的个数)1) 先进先出的算法(FIFO)2) 最久未使用算法(LRU)3. 提示l 随机指令的产生 rand() 或srand()l 用户内存中页面控制结构采用链表 页面控制结构 struct p_str{ int pagenum; /* 页号 */ int count; /* 访问页面的次数 */struct p_str next; /* 下一指针 */}p_str;