操作系統文件課程設計
⑴ 「計算機操作系統」課程設計
你要出書嗎？？
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;