操作系统课程设计试验报告格式.docx

操作系统课程设计试验报告格式.docx

《操作系统课程设计试验报告格式.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计试验报告格式.docx（27页珍藏版）》请在冰点文库上搜索。

操作系统课程设计试验报告格式

四川大学

操作系统课程设计报告

学院：

软件学院

专业：

软件工程专业

年级：

07级

组编号：

第X组

组成员：

乔心轲（姓名）0743111340（学号）

何赵平（姓名）XXXXXXXX（学号）

崔蓉（姓名）XXXXXXXX（学号）

张雯（姓名）XXXXXXXX（学号）

康小芳（姓名）XXXXXXXX（学号）

提交时间：

2009年月日

指导教师评阅意见：

.

..

..

指导教师评阅成绩：

XXX1：

XXX1：

XXX1：

XXX1：

XXX1：

实验项目一

项目名称：

实验目的：

实验时间：

人员分工：

实验环境：

实验环境的搭建过程、选用的操作系统、机器配置、编译器等。

实验内容：

对实践过程的详细说明，针对已经满足的实践要求，采用了何种算法或思想，对Nachos平台的哪些代码进行了什么样的修改。

实验结果：

对实践要求的满足程度，代码是否编写完成，是否调试通过，能否正常运行，本项目的要求中共满足了哪几项。

参考文献：

实验项目二

实验项目名称：

Nachos中的线程管理

实验项目目的：

1.最多能够同时存在128个用户线程

2.改变为遵循“优先级调度”的抢占式调度

参与人员及分工：

乔心轲，何赵平，康小芳完成主要代码编写；

崔蓉，张文进行程序的测试及维护。

实验环境：

⏹Nachos:

NotAnotherCompletelyHeuristicOperatingSystem

⏹Linux

⏹Gcc

⏹Windows

实验内容：

1.对于最多能够同时存在128个用户线程，我们在Thread.cc中声明了一个static变量numOfThreads；具体代码如下：

staticintnumOfThreads=0;//thecountofthethreads

在Thread的构造函数中对其值进行加1；即每创建一个线程时，都会把numOfThreads加1；

++numOfThreads;

并在SimpleThread（）中进行了如下修改，完成了最多能够同时存在128个用户线程。

staticvoid

SimpleThread（intwhich）

{

if（numOfThreads<128）{

for（inti=0;i<（kernel->currentThread->Time（））-（kernel->currentThread->executeTime）+2;i++）{

cout<<"***thread"<currentThread->executeTime<<"times.\n";

cout<<"priority"<currentThread->Priority（）<<"\n";

kernel->currentThread->Yield（）;

}

}

else{

if（count==0）

printf（"Thenumberofthethreadscannotbelargerthan128!

\n"）;

kernel->currentThread->Yield（）;

count++;

}

}

为了实现遵循“优先级调度”的抢占式调度策略，首先为Thread增加了三个变量：

executeTime；time；priority

在Thread.h中对它们的声明：

public:

Thread（char*debugName）;//initializeaThread

~Thread（）;//deallocateaThread

//NOTE--threadbeingdeleted

//mustnotberunningwhendelete

//iscalled

intexecuteTime;//Thetimethatthisthreadhasexecuted

//basicthreadoperation

voidsetExTime（intexT）;//settheexecuteTimeofthethreadtoexT

intTime（）;//returnthetimethatthethreadshouldbeserved

voidsetTime（intt）;//setthetimethatthethreadshouldbeservedtot

voidsetPriority（intpri）;//setthepriorityofthethreadtopri

intPriority（）;//returnthepriorityofthethread

private:

//someoftheprivatedataforthisclassislistedabove

inttime;//thetimethatthethreadshouldbeservedintpriority;//thepriorityofeachthread

在Thread.cc中的实现：

Thread:

:

Thread（char*threadName）

{

name=threadName;

stackTop=NULL;

stack=NULL;

status=JUST_CREATED;

for（inti=0;i

machineState[i]=NULL;//notstrictlynecessary,since

//newthreadignorescontents

//ofmachineregisters

}

space=NULL;

executeTime=1;

setPriority（0）;

setTime

（2）;

}

在Fork（）中对numOfThreads进行了+1操作：

void

Thread:

:

Fork（VoidFunctionPtrfunc,void*arg）

{

Interrupt*interrupt=kernel->interrupt;

Scheduler*scheduler=kernel->scheduler;

IntStatusoldLevel;

DEBUG（dbgThread,"Forkingthread:

"<

"<<（int）func<<""<

StackAllocate（func,arg）;

oldLevel=interrupt->SetLevel（IntOff）;

scheduler->ReadyToRun（this）;//ReadyToRunassumesthatinterrupts

//aredisabled!

（void）interrupt->SetLevel（oldLevel）;

++numOfThreads;

}

//---------------------------------------------------------------------

//Thread:

:

setExTime

//settheexecuteTimeofthethreadtoexT

//---------------------------------------------------------------------

void

Thread:

:

setExTime（intexT）{

executeTime=exT;

}

//---------------------------------------------------------------------

//Thread:

:

setPriority

//setthepriorityofthethreadtopri

//---------------------------------------------------------------------

void

Thread:

:

setPriority（intpri）

{

priority=pri;

}

//---------------------------------------------------------------------

//Thread:

:

Priority

//returnthepriorityofthethread

//---------------------------------------------------------------------

int

Thread:

:

Priority（）{

returnpriority;

}

//---------------------------------------------------------------------

//Thread:

:

setPriority

//setthetimeofthethreadtot

//---------------------------------------------------------------------

void

Thread:

:

setTime（intt）{

time=t;

}

//---------------------------------------------------------------------

//Thread:

:

Time

//returnthetimeofthethreadneedtorun

//---------------------------------------------------------------------

int

Thread:

:

Time（）{

returntime;

}

并在SimpleThread（）中进行了如下修改：

staticvoid

SimpleThread（intwhich）

{

if（numOfThreads<128）{

for（inti=0;i<（kernel->currentThread->Time（））-（kernel->currentThread->executeTime）+2;i++）{

cout<<"***thread"<currentThread->executeTime<<"times.\n";

cout<<"priority"<currentThread->Priority（）<<"\n";

kernel->currentThread->Yield（）;

}

}

else{

if（count==0）

printf（"Thenumberofthethreadscannotbelargerthan128!

\n"）;

kernel->currentThread->Yield（）;

count++;

}

}

对Scheduler.cc中进行了以下修改，实现了按照优先级进行线程的调度，返回最高优先级的线程，让其运行。

Thread*

Scheduler:

:

FindNextToRun（）

{

ASSERT（kernel->interrupt->getLevel（）==IntOff）;

if（readyList->IsEmpty（））{

returnNULL;

}else

{

Thread*highestPri=readyList->RemoveFront（）;

for（inti=1;iNumInList（）;i++）{

if（readyList->IsEmpty（））{

returnhighestPri;

}

if（readyList->Front（）->Priority（）<=highestPri->Priority（））{

readyList->Append（highestPri）;

highestPri=readyList->RemoveFront（）;;

}

}

returnhighestPri;

}

}

并在Run（）中进行了以下修改：

在Run（）代码的最后加了以下语句：

kernel->currentThread->setPriority（kernel->currentThread->Priority（）+1）;

kernel->currentThread->setExTime（kernel->currentThread->executeTime+1）;

实验结果和结论：

对实验进行的测试，首先编译通过测试：

经过编译测试，程序已完成了以上要求，具体测试如下：

对遵循“优先级调度”抢占式调度的实现：

void

Thread:

:

SelfTest（）

{

DEBUG（dbgThread,"EnteringThread:

:

SelfTest"）;

for（inti=0;i<=3;i++）{

Thread*t=newThread（"forkedthread"）;

t->setPriority（3-i）;

t->Fork（（VoidFunctionPtr）SimpleThread,（void*）numOfThreads）;

}

}

对最多只有128个用户线程存在的实现：

参考文献：

实验项目三

实验项目名称：

Nachos中的文件管理系统

实验项目目的：

•实现多个线程同时存在内存，虚拟地址到物理地址的转换，限制程序大小，不实现缺页中断处理

•不实用虚拟内存

•维护二类页表

–实页页表（空闲页表）：

操作系统维护

（Machine中创建）——nachos现在有多少页表是可以供用户使用

–线程页表：

各线程维护自己的页表

参与人员及分工：

乔心轲，何赵平，康小芳完成主要代码编写；

崔蓉，张文进行程序的测试及维护。

实验环境：

⏹Nachos:

NotAnotherCompletelyHeuristicOperatingSystem

⏹Linux

⏹Gcc

⏹Windows

实验内容：

首先是在Machine.h中对空闲页表及其相关函数进行了声明：

TranslationEntry*freePageTable;//空闲页表

TranslationEntryNextFreePage（）;//下一个空闲的页

intNumOfFreePage（）;//剩余空闲页的数目

其次在Machine.cc中空闲页表进行初始化以及函数的实现：

Machine:

:

Machine（booldebug）

{

inti;

for（i=0;i

registers[i]=0;

mainMemory=newchar[MemorySize];

for（i=0;i

mainMemory[i]=0;

freePageTable=newTranslationEntry[NumPhysPages];

for（i=0;i

freePageTable[i].virtualPage=i;

freePageTable[i].physicalPage=i;

freePageTable[i].valid=TRUE;

freePageTable[i].use=FALSE;

freePageTable[i].dirty=FALSE;

freePageTable[i].readOnly=FALSE;

}

#ifdefUSE_TLB

tlb=newTranslationEntry[TLBSize];

for（i=0;i

tlb[i].valid=FALSE;

pageTable=NULL;

#else//uselinearpagetable

tlb=NULL;

pageTable=NULL;

#endif

singleStep=debug;

CheckEndian（）;

}

//----------------------------------------------------------------------

//Machine:

:

NextFreePage（）

//----------------------------------------------------------------------

TranslationEntry

Machine:

:

NextFreePage（）{

for（inti=0;i

{

if（freePageTable[i].valid==TRUE）

returnfreePageTable[i];

}

}

//----------------------------------------------------------------------

//Machine:

:

numOfFreePage（）

//----------------------------------------------------------------------

int

Machine:

:

NumOfFreePage（）{

intnum=0;

for（inti=0;i

{

if（freePageTable[i].valid==TRUE）

num++;

}

returnnum;

}

对AddrSpace.cc的修改如下：

AddrSpace:

:

AddrSpace（）

{

}

AddrSpace:

:

~AddrSpace（）

{

if（pageTable!

=NULL）{

for（inti=0;i

pageTable[i].valid=TRUE;

pageTable[i].use=FALSE;

pageTable[i].dirty=FALSE;

pageTable[i].readOnly=FALSE;

}

deletepageTable;

}

}

为了实现限制程序大小以及实现线程页表和空闲页表的转换，对代码进行了如下修改：

bool

AddrSpace:

:

Load（char*fileName）

{

OpenFile*executable=kernel->fileSystem->Open（fileName）;

NoffHeadernoffH;

unsignedintsize;

if（executable==NULL）{

cerr<<"Unabletoopenfile"<

returnFALSE;

}

executable->ReadAt（（char*）&noffH,sizeof（noffH）,0）;

if（（noffH.noffMagic!

=NOFFMAGIC）&&

（WordToHost（noffH.noffMagic）==NOFFMAGIC））

SwapHeader（&noffH）;

ASSERT（noffH.noffMagic==NOFFMAGIC）;

#ifdefRDATA

//howbigisaddressspace?

size=noffH.code.size+noffH.readonlyData.size+noffH.initData.size+

noffH.uninitData.size+UserStackSize;

//weneedtoincreasethesize

//toleaveroomforthestack

#else

//howbigisaddressspace?

size=noffH.code.size+noffH.initData.size+noffH.uninitData.size

+UserStackSize;//weneedtoincreasethesize

//toleaveroomforthestack

#endif

numPages=divRoundUp（size,PageSize）;

size=numPages*PageSize;

ASSERT（numPages<=NumPhysPages）;//checkwe'renottrying

//torunanythingtoobig--

//atleastuntilwehave

//virtualmemory

DEBUG（dbgAddr,"Initializingaddressspace:

"<

pageTable=newTranslationEntry[numPages];

if（kernel->machine->NumOfFreePage（）>=numPages）{

for（inti=0;i

TranslationEntrytemp=kernel->machine->NextFreePage（）;

pageTable[i].virtualPage=temp.virtualPage;

pageTable[i].p