Nachos操作系统实验报告

合集下载

Nachos实验报告10

计算机科学与技术学院实验报告：10实验题目：具有二级索引的文件系统姓名：李威日期：2013-12-1 学号：201100300259Email：sduliwei@实验目的：Nachos的文件系统中保存文件内容所在扇区索引的“文件头“目前只占用一个扇区，为了可以使Nachos文件系统创建较大的文件，将”文件头”扩大到两个扇区，也就是实现二级索引。

硬件环境：软件环境：Linux操作系统，Nachos操作系统实验步骤：1，通过实验5的扩展文件大小的实验，了解了nachos 系统的对文件系统的管理。

本次实验的目的主要是扩大Nachos系统可以创建的文件的大小，使用两个扇区来保存文件头的信息。

为了达到这个目的，首先了解nachos 自带的文件系统的文件头的结构：保存在一个扇区中，第一个int保存了文件的字节数（numBytes），第二个int保存了使用的扇区数（numSectors），第三个数据结构是文件所在的各个扇区号（dataSectors[NumDiresct]）。

也就是说，Nachos系统采用的是索引式的文件管理方式。

因而，要实现nachos文件系统的二级索引，可以使第一个索引节点（也就是原有的文件头那个扇区）的dataSectors数组的最后一个元素保留第二个索引节点（也就是第二个扇区）的引用（也就是扇区号）。

如果文件大小不超过一个索引节点可以保留的内容，则这个最后一个元素的值为-1。

2，通过分析可知，需要修改中的内容。

代码如下：boolFileHeader::Allocate(BitMap *freeMap, int fileSize){numBytes = fileSize;numSectors = divRoundUp(fileSize, SectorSize);if (freeMap->NumClear() < numSectors)return FALSE; // not enough space/*如果文件大小超过索引节点中保存扇区号的数目，则返回false*/else if(NumDirect + NumDirect2 <= numSectors)return FALSE;//the filesys cannot support such big file/*toNextNode 是保留第二个索引节点的扇区号*/int toNextNode=NumDirect-1; //toNextNode is the Sector number of the second node of the filehd//if the second node is not needed, then dataSector[toNextNode]=-1if(numSectors < toNextNode){for (int i = 0; i < numSectors; i++)dataSectors[i] = freeMap->Find();//为文件分配扇区dataSectors[toNextNode] = -1;}//If the numSectors excends the rage of dataSectors,else{for (int i = 0; i < toNextNode; i++)dataSectors[i] = freeMap->Find();dataSectors[toNextNode] = freeMap->Find();//找一个空闲的扇区，作为第二个扇区，索引节点//this is the content,i.e.filehdr of the allocated sectors, of the second nodeint dataSectors2[NumDirect2];for (int i = 0; i < numSectors - NumDirect; i++)dataSectors2[i] = freeMap->Find();//为文件分配扇区//the fefault synchDisk->WriteSector do not include the second node//so write back the new build nodesynchDisk->WriteSector(dataSectors[toNextNode], (char *)dataSectors2); }return TRUE;/*revised*/}voidFileHeader::Deallocate(BitMap *freeMap){/*toNextNode 是保留第二个索引节点的扇区号*/int toNextNode= NumDirect - 1;// test if has the second nodeif(dataSectors[toNextNode]==-1){for (int i = 0; i < numSectors; i++){ASSERT(freeMap->Test((int) dataSectors[i])); // ought to be marked!freeMap->Clear((int) dataSectors[i]);}}//has a second node, then find it, then clean the bitmap, thenelse{//clear the first n-1 bit,remain the toNextNodeint i=0;for ( ; i < toNextNode; i++){ASSERT(freeMap->Test((int) dataSectors[i])); // ought to be marked!freeMap->Clear((int) dataSectors[i]);}int dataSectors2[NumDirect2];synchDisk->ReadSector(dataSectors[toNextNode], (char *)dataSectors2);freeMap->Clear((int) dataSectors[toNextNode]);//clear the toNextNodefor( ; i < numSectors; i++)freeMap->Clear((int) dataSectors2[i-toNextNode]);//toNextNode==the number of filehdr item }}intFileHeader::ByteToSector(int offset){ASSERT(offset<=numBytes);/*toNextNode 是保留第二个索引节点的扇区号*/int toNextNode = NumDirect - 1; //test if offset excedes the first nodeif(offset / SectorSize < toNextNode)return(dataSectors[offset / SectorSize]);else{int dataSectors2[NumDirect2];synchDisk->ReadSector(dataSectors[toNextNode], (char *)dataSectors2);return (dataSectors2[offset / SectorSize - toNextNode]);}}voidFileHeader::Print(){/*revised*/int i, j, k;/*toNextNode 是保留第二个索引节点的扇区号*/int toNextNode = NumDirect - 1;char *data = new char[SectorSize];//test if there is a second nodeif(dataSectors[toNextNode] == -1){printf("FileHeader contents. File size: %d. File blocks:\n", numBytes); for (i = 0; i < numSectors; i++)printf("%d ", dataSectors[i]);printf("\nFile contents:\n");for (i = k = 0; i < numSectors; i++) {synchDisk->ReadSector(dataSectors[i], data);for (j = 0; (j < SectorSize) && (k < numBytes); j++, k++) {if ('\040' <= data[j] && data[j] <= '\176') // isprint(data[j])printf("%c", data[j]);elseprintf("\\%x", (unsigned char)data[j]);}printf("\n");}}// If there is a secondary index,// first read in the dataSectors2 from the Disk.// Then, deallocate the data blocks for this file.// At last, deallocate the block that dataSector2 locates.else{int dataSectors2[NumDirect2];synchDisk->ReadSector(dataSectors[toNextNode], (char *)dataSectors2);//1, print the filedre itemsprintf("FileHeader contents. File size: %d. File blocks:\n", numBytes);for (i = 0; i < toNextNode; i++)printf("%d ", dataSectors[i]);for(; i < numSectors; i++)printf("%d ", dataSectors2[i - toNextNode]);printf("\nFile contents:\n");//2,print the content of the first node pointedfor (i = k = 0; i < toNextNode; i++) {synchDisk->ReadSector(dataSectors[i], data);for (j = 0; (j < SectorSize) && (k < numBytes); j++, k++) {if ('\040' <= data[j] && data[j] <= '\176') // isprint(data[j])printf("%c", data[j]);elseprintf("\\%x", (unsigned char)data[j]);}printf("\n");}//3,print the content of the second node pointedfor( ; i < numSectors; i++) {synchDisk->ReadSector(dataSectors2[i - toNextNode], data);for (j = 0; (j < SectorSize) && (k < numBytes); j++, k++) {if ('\040' <= data[j] && data[j] <= '\176') // isprint(data[j])printf("%c", data[j]);elseprintf("\\%x", (unsigned char)data[j]);}printf("\n");}}delete [] data;/*revised*/}boolFileHeader::AppSectors(BitMap *freeMap, int appFileSize){/*revised*/if(appFileSize <= 0)return false;int restFileSize = SectorSize * numSectors - numBytes;if(restFileSize >= appFileSize){numBytes += appFileSize;return true;}else{int moreFileSize = appFileSize - restFileSize;if(freeMap->NumClear()< divRoundUp(moreFileSize, SectorSize))return FALSE;else if(NumDirect + NumDirect2 <= numSectors + divRoundUp(moreFileSize, SectorSize)) return FALSE;int i = numSectors;numBytes += appFileSize;numSectors += divRoundUp(moreFileSize, SectorSize);/*toNextNode 是保留第二个索引节点的扇区号*/int toNextNode = NumDirect-1; //test if has the second nodeif(dataSectors[toNextNode] == -1){//test if need the second nodeif(numSectors < toNextNode)for( ; i < numSectors; i++)dataSectors[i] = freeMap -> Find();//need the second nodeelse{for( ; i< toNextNode ; i++)dataSectors[i]= freeMap ->Find();dataSectors[toNextNode] = freeMap ->Find();int dataSectors2[NumDirect2];for ( ; i < numSectors ; i++)dataSectors2[i - toNextNode] = freeMap->Find();synchDisk->WriteSector(dataSectors[toNextNode], (char *)dataSectors2);}}/** If before appending, there is already a secondary index*///First read the dataSectors2 from the Disk.//Then, append the file size.//At last, write back the secondary index block into the sector,else{int dataSectors2[NumDirect2];synchDisk->ReadSector(dataSectors[toNextNode], (char *)dataSectors2);for( ; i < numSectors; i++)dataSectors2[i-toNextNode] = freeMap -> Find();//the var toNextNode==the number of int that synchDisk->WriteSector(dataSectors[toNextNode], (char *)dataSectors2);//the fefault synchDisk}}return TRUE;/*revised*/}运行结果：首先运行命令 ./nachos –f 格式化Nachos磁盘然后运行 ./nachos –ap test/big big 若干次，知道出现提示，文件太大不能再追究为止。

Nachos实验报告9

计算机科学与技术学院实验报告：9实验题目：设计并实现具有优先级的线程调度策略姓名：李威日期：2013-12-1 学号：201100300259 班级：11级软件3班Email：sduliwei@实验目的：Nachos系统采用基本的FCFS的线程调度策略，修改成为具有优先级的线程调度策略硬件环境：软件环境：linux操作系统，Nachos操作系统实验步骤：1．修改Thread类的构造函数，加入优先级priority属性，并且加入getPrioty方法。

以便在线程的等待队列中找到优先级最高的线程。

其中，线程优先级的范围从1到7，默认为7，即最低优先级。

修改代码如下：（,thread.h）class Thread {……………………………………public:Thread(char* debugName, int priority=7);// initialize a Thread …………………………………………………int getPriority(){return this->priority;}Thread::Thread(char* threadName, int p){if(p<1) priority = 1;else if(p>7) priority = 7;else priority = p;name = threadName;stackTop = NULL;stack = NULL;status = JUST_CREATED;#ifdef USER_PROGRAMspace = NULL;#endif}2，首先，了解Nachos系统原来的线程调度方式。

通过读,,文件中的内容了解线程调度的方式。

首先，修改文件中的ThreadTest方法，创建有优先级的Thread，代码如下：然后，从Thread类中找到Fork方法，代码如下：这说明ThreadTest方法的目的是，实例化新的线程，调用Fork方法，也就是让新产生的线程去执行SimpleThread方法，并且把当前执行的线程加入到等待队列。

操作系统实验报告1

姓名：刘桂良
硬件环境：Ubuntu12.8.1-mips.tar.gz 和 nachos-3.4-2011.tar.gz 拷贝到主文件夹中，解压 nachos。 $ tar xzvf nachos-3.4-2011.tar.gz 输入 su，输入密码，进入 root 用户下， cp gcc-2.8.1-mips.tar.gz /usr/local $tar xzvf gcc-2.8.1-mips.tar.gz 在普通用户下，转到 threads 目录下， cd /nachos3.4/code/threads 之后输入 make 之后，测试 nachos 系统测试成功结果如下：
软件学院实验报告
实验题目：Installation of Nachos System 日期：2013-11-1 班级： 11 级 3 班 Email：61536799@ 实验目的：安装 Nachos 和 Mips gcc 交叉编译了解基本 Nachos 系统组织结构学号： 201100300144
结论分析与体会：通过这次实验，熟悉了 C++语言和系统开发调试，理解 Nachos 系统的 Makefile，掌握重构 Nachos 系统的方法。

nachos系统实验报告：实验二

实验二一.实验目的将nachos 中的lock 和condition 类的实现补充完整，并利用这些同步机制实现两个基础功能。

二.实验内容1) 实现syncy.h 中的Lock 和Condition 类，并利用这些同步机制将实验一中所双向有序链表类修改成可以在多线程线程环境下运行。

2) 实现一个线程安全的Table 。

Table 有一个固定大的Entery 数组。

3) 实现一个大小受限的BoundBuffer ，可以完成读.写功能，其中读写的size 可以超过设定的buffer 大小，当读的东西太快或写的太慢时，就将其挂起。

当buffer 里重新有写的空间或读的空间时在将其线程放入就绪队列中。

三.实验结果1.锁机制的实现 **因为lock 和condition 都有两个版本，所以当调用取得锁和释放锁的函数时我用的是GetLock()和ReleaseLock(),而不是lock->Acquire(),Condition 同理用的是Signal （）和Wait （）。

这些函数会根据运行程序时输入的参数来决定用哪个版本的锁或者不用锁。

a)主要代码分析 Lock 类的主要成员{public ： void Acquire(); // 得到锁 void Release(); // 解放锁private: Thread *LockedThread ; // 用于储存现在拥有 lock 的线程 LockStatus status ; // 表示此时lock 的状态（Busy ，Free ） List *queue // 用于保存挂起的线程}Lock 类中Acquire 函数得到锁，如果此时别的线程拥有锁，则此时线程被挂起放在queue 队列中,直到有人释放锁时，Release 函数将queue 中的一个线程加入就绪队列，每次只能由一个线程得到锁。

Condition 类主要成员{ public: void Wait(LockO *conditionLock); void Signal(LockO *conditionLock); private:List *queue ; char* name;}Condition 类的所有操作都在线程得到锁时进行操作，且运行其函数时，都先检测 lock 是否被currentThread 锁拥有。

操作系统nachos课程设计实验报告

一题目project1：实现nachos操作系统的project1中的join（）方法，condition2 类，Alarm类,Communicator类,PriorityScheduler类和Boat类project2：实现nachos操作系统的project2中的creat open read write close unlink 文件系统调用，修改UserProcess.readVirtualMemory和UserProcess.writeVirtualMemory使操作系统能够运行多用户程序，实现exec join exit系统调用，实现LotteryScheduler类二实验目的熟悉nachos操作系统，深入理解操作系统内核了解用户程序的加载过程以及多用户进程的内存分配机制三实验要求完成nachos，提交设计文档和你的代码四实验说明，程序代码及测试结果Project1：1 join()要求实现join（）方法，注意，其他线程没必要调用join函数，但是如果它被调用的话，也只能被调用一次。

join（）方法第二次调用的结果是不被定义的，即使第二次调用的线程和第一次调用的线程是不同的。

无论有没有被join，一个进程都能够正常结束（a）设计思想当线程B执行A.join()时，将B放入A的等待队列，直到A完成时，唤醒在等待队列中的所有线程，因此需要实现join（）方法和修改finish方法（b）源代码public void join(){Lib.debug(dbgThread, "Joining to thread:" + toString());Lib.assertTrue(this!=currentThread);Lib.assertTrue(join_counter == 0);join_counter++;boolean status=Machine.interrupt().disable();if (this.status != statusFinished) {waitQueue.waitForAccess(KThread.currentThread());currentThread.sleep();}Machine.interrupt().restore(s tatus);}public static void finish(){Lib.debug(dbgThread, "Finishing thread:" +currentThread.toString());Machine.interrupt().disable();Machine.autoGrader().finishingCurrentThread();Lib.assertTrue(toBeDestroyed == null);toBeDestroyed= currentThread;currentThread.status = statusFinished;KThread thread= currentThread().waitQueue.nextThread();if (thread!= null){thread.ready();}sleep();}（c）程序截图线程1每次执行打出执行的次数，每次执行过后放弃cpu，线程2 打出successful，线程2 执行thread1.join().通过截图可以看出代码正确2 Condition2通过使用开关中断提供原子性来直接实现条件变量，我们利用信号量提供了一个简单的实现方式，你的工作就是不直接使用信号量提供相同的实现（你或许使用锁，即使它们也间接的使用了信号量）。

nachos实验报告

nachos实验报告nachos实验报告一、引言操作系统是计算机系统中的核心软件之一，它负责管理计算机的硬件资源和提供各种服务。

为了更好地理解操作系统的原理和设计，我们在课程中进行了一系列的实验，其中之一就是使用nachos操作系统进行实验。

本报告将对我们在nachos实验中的学习和体验进行总结和分享。

二、nachos简介nachos是一个教学用的操作系统，它是为了帮助学生更好地理解操作系统的原理和设计而开发的。

nachos的设计简单、模块化，易于理解和扩展。

通过使用nachos，我们可以深入了解操作系统的各个组成部分，如进程管理、内存管理、文件系统等，并通过实验来加深对这些概念的理解。

三、实验一：进程管理在第一个实验中，我们学习了进程管理的基本原理和实现。

通过使用nachos，我们可以创建和管理多个进程，并学习它们之间的通信和同步机制。

我们了解了进程的状态转换、进程调度算法以及进程间通信的方法，如共享内存和消息传递等。

通过实验，我们更深入地理解了进程管理的重要性和挑战。

四、实验二：内存管理在第二个实验中，我们学习了内存管理的原理和实现。

nachos提供了虚拟内存的支持，我们可以通过设置页表和实现页面置换算法来管理内存。

我们了解了内存分页和分段的概念，以及常见的页面置换算法，如FIFO、LRU等。

通过实验，我们深入了解了内存管理的工作原理和性能优化方法。

五、实验三：文件系统在第三个实验中，我们学习了文件系统的原理和实现。

nachos提供了一个简单的文件系统接口，我们可以通过创建、读取和写入文件来学习文件系统的操作。

我们了解了文件系统的组织结构，如目录、文件和索引节点等，并学习了文件系统的一致性和恢复机制。

通过实验，我们更好地理解了文件系统的工作原理和性能优化方法。

六、实验四：网络通信在第四个实验中，我们学习了网络通信的原理和实现。

nachos提供了一个简单的网络模拟器，我们可以创建和管理多个网络节点，并通过网络进行通信。

Nachos文件系统实习报告

• 在本次实习中，我深入了解了Nachos文件系统的设计、实现和应用。通过实践操作，我掌握了Nachos文件系统的基本原理和核心功能，并对其在实际应用中的优缺点有了更深刻的认识。
THANK YOU
感谢观看
实习目的
01 掌握Nachos文件系统的基本原理和架构。
02 了解文件系统的数据结构、存储管理、I/O 操作等核心组件。
03
通过实践操作，提高解决实际问题的能力。
04
培养对文件系统领域的兴趣，为未来的学习和工作打下基础。
02
Nachos文件系统概述
Nachos文件系统简介
01
Nachos文件系统是一种分布式文件系统，旨在为大
灵活性
支持多种存储介质和存储架构，可根据实际需求进行配置和扩展。
易用性
提供友好的用户界面和丰富的API接口，方便用户进行开发和集成。
Nachos文件系统的应用场景
科学计算
适用于气象、生物信息学、物理模拟等领域，提供大规模数据存储和处理能力。
云计算
作为云平台的底层存储基础设施，为虚拟机和容器提供文件存储服务。
Nachos文件系统实习报告
汇报人： 202X-01-07
目录
• 引言 • Nachos文件系统概述 • 实习内容与过程 • 实习成果与收获 • 总结与展望
01
引言
实习背景
• 在当今信息时代，文件系统作为计算机存储和管理数据的关键组件，其重要性不言而喻。 Nachos是一款模拟真实文件系统的开源软件，为学习和研究文件系统提供了良好的实验平台。本次实习旨在通过实践Nachos 文件系统，深入了解文件系统的基本原理、实现机制以及性能优化等方面的知识。

实验三-操作系统实验Nacho

实验内容利用事实验三操作系统实验Nacho、实验人员:、实验目的：本次实验的目的在于掌握使用 nachos 中的线程序解决较为复杂的并发问题。

分三部分：实现事件栅栏原语并进行正确性测试；实现闹钟原语并进行正确性测试; 件栅栏和闹钟原语来解决电梯问题（详细内容请看 nachos-labs.pdf ）。

三、实验内容：1. 实现事件栅栏原语2. 实现闹钟原语3. 解决电梯问题四、实验步骤：1. 实现事件栅栏原语#ifndef EVENTBARRIER_H#defi ne EVENTBARRIER_H#in clude "syn ch-sem.h"#defi ne SIGNALED 1#defi ne UNSIGNALED 0 class Eve ntBarrier{ public:Eve ntBarrier();~Eve ntBarrier();void Wait();void Sig nal();void Complete。

;int Waiters。

； private:bool state;Con diti on *waits;Con diti on *waitc;Lock *barrier;Lock *in barrier;int waiter;};#en dif#i nclude "Eve ntBarrier.h"#in clude "thread.h"Even tBarrier::Eve ntBarrier()waits=new Con diti on ("waitsig nal");waitc=new Condition("waitcomplete");barrier=new Lock("barrier"); inbarrier=new Lock("inbarrier");state=UNSIGNALED;waiter=0;}EventBarrier::~EventBarrier() {delete waits;delete waitc;}void EventBarrier::Wait(){barrier->Acquire();waiter++;while(state==UNSIGNALED)waits->Wait(barrier);barrier->Release();}void EventBarrier::Signal()barrier->Acquire();state=SIGNALED;waits->Broadcast(barrier);barrier->Release();inbarrier->Acquire();waitc->Wait(inbarrier);inbarrier->Release();state=UNSIGNALED;}void EventBarrier::Complete(){inbarrier->Acquire();waiter--;if(waiter==0){waitc->Broadcast(inbarrier);}else{waitc->Wait(inbarrier);}inbarrier->Release();int Even tBarrier::Waiters(){return waiter;}2. 实现闹钟原语#defi ne ALARM_H#in clude "system.h"#i nclude "list.h" class Alarm{ public:Alarm();~Alarm();void Pause(i nt howL on g); void Wakeup();int Getpause num(); private:List *queue;int pause num;int leftime;};#en dif#in elude "system.h"#in elude "thread.h"#in elude "Alarm.h"exter n Alarm *alarm;void check(i nt which){while(alarm->Getpause num ()!=0){curre ntThread->Yield();}curre ntThread->Fi nish();}Alarm::Alarm(){queue=new List();pause num=0;}Alarm::~Alarm()queue->~List();}void Alarm::Pause(int howLong){Thread *t;pausenum++;if(pausenum==1){t=new Thread("forked thread");t->Fork(check,0);}if(howLong<=0)return;leftime=stats->totalTicks+howLong*TimerTicks*10000;IntStatus oldlevel=interrupt->SetLevel(IntOff);queue->SortedInsert(currentThread,leftime);currentThread->Sleep();(void) interrupt->SetLevel(oldlevel);}void Alarm::Wakeup()Thread *thread;int ptime=-1;IntStatus oldLevel = interrupt->SetLevel(IntOff);thread = (Thread *)queue->SortedRemove(&ptime);(void) interrupt->SetLevel(oldLevel);while( thread != NULL ){if(stats->totalTicks>=ptime){scheduler->ReadyToRun(thread);pausenum--;oldLevel = interrupt->SetLevel(IntOff);thread = (Thread *)queue->SortedRemove(&ptime);(void) interrupt->SetLevel(oldLevel);continue;}else{oldLevel = interrupt->SetLevel(IntOff);queue->SortedInsert(thread,ptime);(void) interrupt->SetLevel(oldLevel);break;}intAlarm::Getpause num() {retur n pause num;}3. 实现单个电梯class Elevator{public:Elevator(char *debug name,i nt nu mfloors,i nt myid);~Elevator();char *getName() { return n ame; }void OpenDoors(); /* 电梯开门 */void CloseDoors(int i); /* 电梯关门 */bool VisitFloor(int floor); /*查看电梯是否访问某层 */bool Enter(int id); /* 乘客进入电梯 */void Exit(int id); /* 乘客离开电梯 */void RequestFloor(int floor); /* 乘客阻塞在电梯内部 */ intGetlD(){return id;}void SetState(int i);bool IFEMPTY();void GoUp();void GoDown();private:char *name;int id;int numFloorsint currentfloor;int occupancy;int MaxNumber;int states; /* 设置电梯状态*//* 电梯是否为空*//* 电梯上行*//* 电梯下行*/; /* 电梯所能到达的最大楼层*//* 目前所在楼层*//* 目前乘客数目*//* 最大乘客数目*//* 电梯状态*/int GetFloor(){return currentfloor;}int GetState(){return states;}EventBarrier *eventbarrier; /* 电梯栅栏 */bool *ifvisitfloor;/* 判断电梯是否停留某楼层的数组 */Lock *occlock;};class Buildingpublic:Building(char *debugname,int numfloors,int numelevators);~Building();char *getName() { return name; }void CallUp(int fromFloor);void CallDown(int fromFloor);Elevator *AwaitUp(int fromFloor); /* 乘客等待，阻塞 ,返回电梯指针 */ Elevator *AwaitDown(int fromFloor); /* 乘客等待，阻塞，返回电梯指针 */ bool GetDownLight(int floor){return DownLight[floor];}bool GetUpLight(int floor){return UpLight[floor];}void SetDownLight(int t,bool i);void SetUpLight(int t,bool i);void WakeUp();void WakeDown();Elevator *TellElevator();private:char *name;int NumElevators; /* 电梯数目 */int NumFloors; /* 楼层数目 */EventBarrier *eventbarrier_up;/* 上行栅栏 */EventBarrier *eventbarrier_down;/* 下行栅栏 */Elevator *elevator; /* 一个电梯 */bool *UpLight; /*楼层上行按键*/｝；#i nclude "syn ch-sleep.h" #in clude "system.h" #i nclude "Eve ntBarrier.h" Even tBarrier::Eve ntBarrier(){eve ntlock=new Lock("eve ntlcok"); complete=new Con diti on ("complete");sig nal=new Con diti on ("sig nal"); SIGNALED=false;waiters_co un t=0;}Even tBarrier::~Eve ntBarrier(){delete even tlock;delete sig nal;delete complete;void EventBarrier::Wait(){eventlock->Acquire();waiters_count++;while(!SIGNALED)/* 如果事件栅状态是 UNSIGNALED, 则阻塞 */signal->Wait(eventlock);eventlock->Release();}void EventBarrier::Signal(){eventlock->Acquire();SIGNALED=true;/* 设置事件栅栏的状态为 SIGNALED*///printf("\n set SIGNALED=true,waiting for all forks WakeUp");signal->Broadcast(eventlock);/* 唤醒所有阻塞于 Signal 的线程 */ complete->Wait(eventlock); /* 阻塞于 Complete*///printf("\n has already signaled all waiting forks");SIGNALED=false;/* 恢复事件栅栏的状态为 UNSIGNALED*///printf("\n has already reset SIGNALED=false\n"); eventlock->Release(); }void EventBarrier::Complete()eve ntlock->Acquire();waiters_co un t--;if(waiters_count==O)/* 最后一个应答，唤醒所有阻塞在complete 的线程*/ complete->Broadcast(eve ntlock);else if(waiters_cou nt>0)/* 并非最后一个应答，阻塞在 complete*/complete->Wait(eve ntlock);elseprin tf("\n waiters_cou nt error!");eve ntlock->Release();}int Even tBarrier::Waiters(){retur n waiters_co unt;}五、实验结果1. 事件栅栏测试结果2•闹钟测试结果3.电梯测试结果普通情况严C^1L4018@C56;电梯满六、实验总结本次实验关于电梯的程序难度较大，特别是电梯部分。

nachos系统实验报告范文实验三

nachos系统实验报告范文实验三实验三一.实验目的学会运用实验二中实现的工具来实现一些多线程并发问题。

二.实验内容态。

线程想通过事件时必须等待事件被另外线程ignal。

只有当所有进入事件的线程完成动作时发出ignal的线程才将事件状态设为unignaled2)AlarmClock：AlarmClock让某个线程停止指定时间单位。

当事件到达时重新将线程放入就绪队列。

3)Bridge：Bridge是一个单行桥且最大允许3量车在桥上行驶。

实现应解决注意公平性与饥饿问题。

4)Elevator：实现Elevator类,并解决3个并发问题a)一个电梯，电梯容量无限。

b)一个电梯，电梯容量有限。

c)多个电梯。

三.实验结果1.EventBarrier类定义：主要函数1）Wait():线程挂起待事件被ignal，当事件已经处于ignaled状态时直接return测试结果：测试中主线程来释放Signal信号。

另4个线程做为等待线程，名字分别为Thread1～4。

Thread1,2在主线程Signal之前就调用Wait()函数，Thread3,4在事件被标志Signaled状态时才调用Wait()。

最终结果如下图所示，事件在四个线程都repone自后才改变状态，四个线程个主线程都运行正确。

Thread1,2进入等待ignal事件2.AlarmClock类定义claAlarm{public:Alarm();~Alarm();voidPaue(inthowLong);voidTh readRetart();private:LockO某lock;ConditionP某conLock;};主要函数：//让线程在howLong事件后开始运行//闹钟结束后重新开始运行线程//此条件变量里的线程队列是按照优先级排列的//每次运行优先级最高的线程voidAlarm::ThreadRetart(){conLock->Signal(NULL);}taticvoidTimeUP(intNoUe){alarmClock->ThreadRetart();}voidAlarm::Paue(inthowLong){lock->Acquire();interrupt->Schedule(TimeUP,0,howLong,AlarmInt);conLock->Wait(lock,tat->totalTick+howLong);lock->Releae();}1）Paue(inthowLong)：让事件停止howLong个时间单位。

Nachos系统调用实习报告

Nachos系统调用实习报告在本次实习中，我参与了Nachos系统的开发与优化工作。

Nachos是一款开源的嵌入式操作系统，旨在提供安全、高效和可靠的计算环境。

通过实习，我希望能够更深入地理解操作系统的内部机制，提升我的系统编程技能，并且在实际项目中运用所学知识。

在进行系统调用设计时，遇到了参数传递的问题。

经过研究，我们决定采用寄存器传递参数，并优化了寄存器的使用方式，提高了调用效率。

在实现文件系统时，遇到了读写性能的问题。

我们通过对文件系统进行优化，包括缓存机制、文件分割等手段，有效地提高了读写性能。

在多任务调度中，遇到了任务优先级冲突的问题。

我们通过引入任务调度器，实现了任务的动态优先级调整，解决了冲突问题。

团队合作：在实习期间，我与团队成员积极沟通，共同解决了许多问题。

我们经常进行技术讨论，分享解决方案，共同优化系统性能。

这种团队合作的方式让我收获颇丰。

在实习过程中，我运用了所学的操作系统知识，如进程管理、文件系统、设备驱动等，对Nachos系统进行优化。

同时，我还学习了汇编语言、C语言以及嵌入式开发的相关知识，并将其应用到实际项目中。

这些知识的应用让我对操作系统有了更深入的理解。

通过实习，我更加深入地理解了操作系统的内部机制和实现方法。

我学会了如何在实际项目中运用所学知识，提高了我的系统编程技能。

我认识到团队合作的重要性，学会了如何与他人协作解决问题。

我认识到自我学习和持续进步的重要性，需要在工作中不断学习和提升。

对某些专业知识掌握不够深入，需要进一步学习。

在解决问题时，有时过于急躁，需要更加耐心地思考和分析问题。

通过本次实习，我更加深入地理解了操作系统的内部机制和实现方法，提高了我的系统编程技能和解决问题的能力。

我也认识到团队合作的重要性，学会了如何与他人协作解决问题。

这些经验和收获将对我未来的学习和工作产生积极的影响。

在过去的六个月中，我有幸在XYZ科技公司的Nachos团队实习，专注于文件系统的开发与优化。

nachos 实验报告

nachos 实验报告
《Nachos 实验报告》
在计算机科学领域，操作系统是一个非常重要的概念。

它是计算机系统的核心组成部分，负责管理计算机的资源并提供用户和应用程序之间的接口。

为了更好地理解操作系统的工作原理，我们进行了一项名为Nachos的实验。

Nachos是一个用于教学目的的操作系统内核。

它是在加州大学伯克利分校开发的，旨在帮助学生学习操作系统的基本概念和原理。

在这个实验中，我们使用Nachos来深入了解操作系统的各个方面，包括进程管理、内存管理、文件系统和网络通信等。

首先，我们学习了Nachos的基本结构和架构。

它由多个模块组成，每个模块负责不同的功能。

通过阅读Nachos的源代码和文档，我们逐渐理解了操作系统内核的组成和工作原理。

接着，我们进行了一系列的实验，来探索Nachos的各种功能。

我们实现了进程管理模块，通过创建和调度多个进程来理解进程的概念和调度算法。

我们还实现了内存管理模块，通过分配和释放内存来了解内存管理的重要性。

此外，我们还实现了文件系统和网络通信模块，以便更好地理解操作系统对外部设备和网络的支持。

通过这些实验，我们不仅加深了对操作系统的理解，还提高了编程和调试的能力。

Nachos实验让我们从理论知识转化为实际操作，让我们更加深入地理解了操作系统的工作原理。

总的来说，Nachos实验为我们提供了一个宝贵的学习机会，让我们对操作系统有了更深入的了解。

通过这个实验，我们不仅学到了知识，还培养了解决问题
的能力和团队合作精神。

希望未来能够继续深入研究操作系统，为计算机科学领域做出更多的贡献。

nachos Lab4实习报告

虚拟内存实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (23)内容四：收获及感想 (24)内容五：对课程的意见和建议 (24)内容六：参考文献 (24)内容一：总体概述实习的主要内容是了解和改进nachos存储管理相关实现，主要分为三个部分。

第一部分的主要内容是实现TLB相关异常处理和置换算法，第二部分的主要内容是实现全局内存管理机制，使得nachos内存可以同时存在复数线程，第三部分的主要内容是实现程序运行时载入所需页面。

扩展部分主要是增加线程挂起状态以及实现倒排页表。

内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3 Exercise4 Exercise5 Exercise6 Exercise7 Y Y Y Y Y Y Y Challenge1 Challenge2Y Y具体Exercise的完成情况一、TLB异常处理目前，Nachos系统对于内存的管理是基于软件模拟的TLB机制。

其工作原理、异常处理、替换算法等方面，与分页式内存管理非常相像。

Exercise1 源代码阅读阅读code/userprog/，着重理解nachos执行用户程序的过程，以及该过程中与内存管理相关的要点。

阅读code/machine目录下的machine.h(cc),translate.h(cc)文件和code/userprog目录下的exception.h(cc)，理解当前Nachos系统所采用的TLB 机制和地址转换机制（1）用户程序执行过程userprog/定义函数StartProcess主要功能是实现用户程序启动，如果我们希望执行test中的用户程序，那么我们进入userprog，执行./nachos -x ../test/（用户程序），通过识别-x参数，nachos调用StartProcess执行用户程序（具体实现在threads/）StartProcess的基本流程是，通过文件系统定义的OpenFile打开相关文件，通过AddrSpace的构造函数建立用户空间，装载文件，通过AddrSpace的InitRegisters函数初始化用户寄存器，通过AddrSpace的RestoreState函数装载页表，通过machine的Run函数运行用户程序AddrSpace的构造函数实现在userprog/，主要流程是，获取文件头，大小端做适宜转换，通过文件头计算文件所需空间，包括代码段，初始化数据段，未初始化数据段，栈空间4个部分，通过文件所需空间计算出文件所需的虚拟页面数量，创建用户空间页表，指示了第i个虚拟页对应第i个物理页，将用户程序的正文段和相关数据依次调入内存AddrSpace的InitRegisters函数实现在userprog/，主要流程是初始化普通寄存器（初始化为0），初始化当前指令指针（PC，初始化为0），初始化下一条指令指针（初始化为4），初始化栈指针（地址空间尾部适当前移）AddrSpace的RestoreState函数实现在userprog/，主要流程是将页表装载到machine类中，准备执行用户程序machine的Run函数实现在machine/，基本流程是通过OneInstruction函数完成指令译码和执行，通过interrupt的OneTick函数使得时钟前进machine的Run函数通过machine的ReadMem函数读内存数据，通过machine 的WriteMem函数写内存数据，两个函数的实现在machine/，核心是translate函数，translate函数实现在machine/，主要功能是实现虚拟地址到物理地址的转换，translate函数可能返回相应的错误，在这样的情况下，ReadMem函数/WriteMem函数调用RaiseException函数进行处理，RaiseException函数定义在machine/，基本流程是将错误信息存储在特定位置，调用ExceptionHandler函数处理不同的错误，ExceptionHandler 函数实现在userprog/，主要流程是根据错误信息处理不同错误。

操作系统实验报告一

实验报告课程名称：操作系统（nachos）Array实验项目名称：进程调度实验时间：2010-09-08班级：姓名：学号：实验目的:用高级语言编写和调试一个有 N个进程并行的进程调度程序，以加深对进程的概念及进程调度算法的理解。

实验环境:PC机、windows XP 操作系统、Visual C++6.0开发工具/Win-TC实验内容及过程:实验内容：设计一个有N个进程并行的进程调度程序。

进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。

具体描述如下：每个进程有一个进程控制块（ PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

分析：进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后按照优先数的大小把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。

重复以上过程，直到所要进程都完成为止。

调度算法的参考流程图如下：实验过程：1．在win-tc环境中编写一个有N个进程并行的进程调度程序,包括最高优先数优先的调度算法和先来先服务算法，代码见附录中。

2．在上机环境中编译、调试程序。

3．设计输入数据，得出程序的执行结果。

实验结果及分析：1、选择最高优先数优先的调度算法调度两个进程：输出进程名、进程cpu时间、进程还需时间、进程优先数及进程状态，最高优先数优先的调度算法调度三个进程：2、选择先来先服务算法调度两个进程：输出进程名、进程开始时间及结束时间，先来先服务算法调度三个进程：实验心得：操作系统第一份实验刚开始确实有点没头绪，而且也刚接触一点儿进程调度的，对它只是大概了解些。

操作系统nachos课程设计实验报告

一题目project1：实现nachos操作系统的project1中的join（）方法，condition2类，Alarm类,Communicator类,PriorityScheduler类和Boat类project2：实现nachos操作系统的project2中的creat open read write close unlink 文件系统调用，修改UserProcess.readVirtualMemory 和UserProcess.writeVirtualMemory使操作系统能够运行多用户程序，实现exec join exit系统调用，实现LotteryScheduler类二实验目的熟悉nachos操作系统，深入理解操作系统内核了解用户程序的加载过程以及多用户进程的内存分配机制三实验要求完成nachos，提交设计文档和你的代码四实验说明，程序代码及测试结果Project1：1 join()要求实现join（）方法，注意，其他线程没必要调用join函数，但是如果它被调用的话，也只能被调用一次。

join（）方法第二次调用的结果是不被定义的，即使第二次调用的线程和第一次调用的线程是不同的。

无论有没有被join，一个进程都能够正常结束（a）设计思想当线程B执行A.join()时，将B放入A的等待队列，直到A完成时，唤醒在等待队列中的所有线程，因此需要实现join（）方法和修改finish方法（b）源代码public void join() {Lib.debug(dbgThread, "Joining to thread: " + toString());Lib.assertTrue(this != currentThread);Lib.assertTrue(join_counter == 0);join_counter++;boolean status = Machine.interrupt().disable();if (this.status != statusFinished) {waitQueue.waitForAccess(KThread.currentThread());currentThread.sleep();}Machine.interrupt().restore(status);}public static void finish() {Lib.debug(dbgThread, "Finishing thread: " +currentThread.toString());Machine.interrupt().disable();Machine.autoGrader().finishingCurrentThread();Lib.assertTrue(toBeDestroyed == null);toBeDestroyed = currentThread;currentThread.status = statusFinished;KThread thread = currentThread().waitQueue.nextThread();if (thread != null){thread.ready();}sleep();}（c）程序截图线程1每次执行打出执行的次数，每次执行过后放弃cpu，线程2打出successful，线程2执行thread1.join().通过截图可以看出代码正确2 Condition2通过使用开关中断提供原子性来直接实现条件变量，我们利用信号量提供了一个简单的实现方式，你的工作就是不直接使用信号量提供相同的实现（你或许使用锁，即使它们也间接的使用了信号量）。

山东大学操作系统课设nachos

操作系统课程设计实验报告——对Nachos系统的完善班级：计软13.4分组：第八组Phase 0一、写在前面二、需要明确的是：Run nachos → ThreadKernel is called to create nachos kernel → initialize() initializes nachos kernel → selfTest() tests this kernel → run() is supposed to run user programs latterSome Crucial requirements:1. Only modify nachos.conf according to the project specifications.2. Do not modify any classes in the nachos.machine package, the nachos.ag package, or the nachos.security package.3. Do not add any new packages to your project.4.Do not modify the API for methods that the autograder uses.5.Do not directly use Java threads (the ng.Thread class).6. Do not use the synchronized keyword in any of your code.7. Do not directly use Java File objects (in the java.io package).Phase 1：Build a thread system for kernel processes Task 1.1Implements Join() method一、问题描述1. Note that another thread does not have to call join(), but if it is called, it must be called only once.2. A thread must finish executing normally whether or not it is joined.二、解决方案线程B在线程A运行的过程中调用join方法，阻塞线程A的运行获取运行权，此时线程A 等待线程B完成运行后重新运行。

NachOS实验报告(4个全)

四川大学操作系统课程设计报告学院：软件学院专业：软件工程专业年级：08级组编号：组成员：提交时间：2010年6月24日指导教师评阅意见：.. . . .指导教师评阅成绩：：：实验项目一项目名称：开发Shell程序试验背景知识Shell此处的shell是指命令行式的shell。

文字操作系统与外部最主要的接口就叫做shell。

shell是操作系统最外面的一层。

shell管理你与操作系统之间的交互:等待你输入，向操作系统解释你的输入，并且处理各种各样的操作系统的输出结果。

shell提供了你与操作系统之间通讯的方式。

这种通讯可以以交互方式（从键盘输入，并且可以立即得到响应），或者以shell script(非交互)方式执行。

shell script是放在文件中的一串shell和操作系统命令，它们可以被重复使用。

本质上，shell script是命令行命令简单的组合到一个文件里面。

Shell基本上是一个命令解释器，类似于DOS下的。

它接收用户命令（如ls等)，然后调用相应的应用程序。

较为通用的shell有标准的Bourne shell (sh)和C shell (csh)。

交互式shell和非交互式shell交互式模式就是shell等待你的输入，并且执行你提交的命令。

这种模式被称作交互式是因为shell与用户进行交互。

这种模式也是大多数用户非常熟悉的：登录、执行一些命令、签退。

当你签退后，shell也终止了。

shell也可以运行在另外一种模式：非交互式模式。

在这种模式下，shell不与你进行交互，而是读取存放在文件中的命令,并且执行它们。

当它读到文件的结尾，shell也就终止了。

实验目的：Shell是一个命令处理器（command processor）——是一个读入并解释你输入的命令的程序，它是介于使用者和操作系统之核心程序（kernel）间的一个接口。

它是一个交互性命令解释器。

shell 独立于操作系统，这种设计让用户可以灵活选择适合自己的shell。

山东大学操作系统实验二实验报告

实验报告
实验题目：安装Nachos系统学号： 201100300038
日期：2013-10-22 班级： 11级3班姓名：陶旭涛
Email： 1595242630@
实验目的：
1.练习安装、编译和测试基本 Nachos 系统
2.了解基本 Nachos 系统组织结构
3.熟悉 C++语言和系统开发调试工具
硬件环境：linux
软件环境： gcc
实验步骤：
1. 将 gcc 和 nachos 拷贝到主文件夹中，解压nachos。

$ tar xzvf nachos-3.4-2011.tar.gz
2. 以root 身份进入系统目录/usr/local,将文件Gcc-2.8.1-mips.tar.gz 复制
到/usr/local 目录中:
，
cp gcc-2.8.1-mips.tar.gz /usr/local
使用 shell 命令安装:
$tar xzvf gcc-2.8.1-mips.tar.gz
3. cd /nachos3.4/code/threads
make
./nachos
结果如下
结论分析与体会：
通过这次实验，我熟悉了操作系统实验的环境，进一步了解了Nachos的构成，对我以后顺利熟练的完成操作系统实验有很大的帮助！。