《计算机操作系统》实验指导书
郑州大学软件学院
实验一操作系统的安装与使用
1．实验目的
（1）熟悉Windows 2000等操作系统系统的定制安装过程，明确各安装部件的作用。要求学生掌握图形用户接口元素和图形用户接口元素的基本操作；熟悉控制面板中各组件的作用及设置；能够了解Windows系统对各种软件资源和硬件资源管理的策略。
（3）结合教材绪论，让学生对系统进程管理、处理机的调度与死锁、存储器管理、设备管理、文件管理以及系统接口有一个感性的认识并熟悉相关操作。2．实验预备知识
（1）阅读教材第一章（操作系统引论），熟悉操作系统的目标、作用和层次；了解操作系统的发展过程；熟悉操作系统实现的功能（存储器管理功能、处理机管理功能、设备管理功能、文件管理功能以及用户接口）；了解操作系统的发展的历史和未来的发展趋势。
3．实验环境
（1）PC计算机;
（2）WINDOWS 2000、WINDOWS XP或WINDOWS SEVER 2003等操作系统的安装盘。
4．实验时间：2个机时。
5．实验内容
（1）了解安装WINDOWS 2000（或WINDOWS XP、WINDOWS SEVER 2003）的硬件需求；
熟悉安装过程。熟悉安装过程中各种组件的选择；设置操作系统双重启动；熟悉各种物理设备驱动程序的安装。
（2）熟悉WINDOWS 2000的用户界面。重点掌握各类操作系统的各类用户接口；掌握资源管理器的使用。
（3）掌握对操作系统的配置和维护，掌握控制面板的使用。掌握安装和删除硬件设备的方法，熟练对打印机、鼠标、键盘、网卡、显示卡、声卡等硬件设备进行配置。
（4）了解网络的配置和网络协议的原理和设置，熟练对计算机进行网络设置。
（5）熟练掌握WINDOWS 2000的管理工具。利用“计算机管理”选项对计算机进行设置。“计算机管理工具”为用户提供六种系统工具：“事件查看器”，“系统信息”、“性能日志和警报”，“共享文件夹”、设备管理器“和”本地用户和组。
（6）了解WINDOWS 2000活动目录。目录是一个存储对象信息的分层结构，要求学生掌握配置活动目录的方法。
（7）掌握WINDOWS 2000的存储管理。要求学生掌握以下内容：WINDOWS 2000的基本存储和动态存储；智能镜像、存储工具、视图的设置和硬盘转换、动态磁盘中的卷以及相关卷的操作、磁盘碎片整理程序。
（8）熟悉用WINDOWS任务管理器来观察计算机的应用程序列表、进程列表以及系统的处理机使用情况、内存分配和使用情况、句柄数、线程数等等。6．思考
WINDOWS操作系统中如何实现了处理机管理、内存管理、设备管理、文件
管理和磁盘管理？如何操作？
有条件的同学可参阅有关LINUX书籍和上机实践，思考和了解在LINUX操作系统中是如何实现了处理机管理、内存管理、设备管理、文件管理和磁盘管理？
实验二生产者和消费者的问题
1．实验目的
（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）验证用信号量机制实现进程互斥的方法。
（4）验证用信号机制实现进程同步的方法。
2．实验预备内容
（1）阅读课本有关进程管理以及进程同步的有关章节，对临界区和临界资源概念要清晰，充分理解信号信号量机制。
（2）阅读几种经典进程同步问题的算法并理解。熟练掌握生产者—消费者的算法思想。
3．实验环境
（1）一台运行Windows 2000 professional操作系统的计算机。
（2）选用turbo c、visual c++、Delphi、c++ builder或visual basic 等任何一种语言。
4．实验时间：4个机时。
5．实验内容
问题描述：考虑有一些生产者和消费者进程，生产者进程生产信息并把它们放入缓冲池中，消费者从缓冲池中取走信息。生产者—消费者问题是相互合作的进程关系的一种抽象，如在输入时，输入进程是生产者，计算进程是消费者；而在输出时，则计算进程是生产者，打印进程是消费者。请使用信号量机制来解决生产者—消费者问题。
缓冲区
互斥关系：
（I）设缓冲池有n个单元。
（II）当n个单元装满时，生产者必须等待。
（III）当缓冲池空时，消费者必须等待。
6．参考算法
Var mutex,empty,full:semaphore:=1,n,0;
buffer:array[0,…,n-1] of item;
in,out:integer:=0,0;
生产者进程：
repeat
produce an item in nextp
wait(empty);
wait(mutex);
buffer(in):=nextp;
in:=(in+1) mod n;
signal(mutex);
signal(full);
until false;
消费者进程：
repeat
wait(full);
wait(mutex);
nextc:=buffer(out);
out:=(out+1) mod n;
signal(mutex);
signal(empty);
consume the item in nextc
wait(S)操作:
S=S-1;
若S>=0，则进程继续运行。
若S<0，则该进程被阻塞，并将它插入该信号量的等待队列中。
Signal(S)操作:
S=S+1;
若S>0,则进程继续执行;
若S<=0,则从信号量等待队列中移处第一个进程,使其变为就绪状态,然后再返回原进程继续执行。
7．实验要求
在程序编制中，应有数据显示，最好采用图形界面显示。生产者和消费者的进程采用程序模拟的方法运行。
实验三 银行家调度算法
1．实验目的
（1）使学生加深对死锁的理解，理解预防死锁的思想和方法，使学生明确系统安全状态的概念。
（2）使学生能利用银行家调度算法实现避免死锁。 2．实验预备内容
阅读死锁的基本概念，产生死锁的原因、产生死锁的必要条件以及处理死锁的基本方法，重点阅读关于死锁避免的章节。 3．实验环境
（1）一台运行Windows 2000 professional 操作系统的计算机。
（2）选用turbo c 、visual c++、delphi 、c++ builder 或visual basic 等任何一种语言，建议用c++。 4．实验时间：4个机时。 5．实验内容
(1)设置银行家算法中的数据结构
(a)可利用资源向量Available
它是一个含有m 个元素的数组，其中的每一个元素代表一类可利用资源的数目，其初始值是系统中所配置该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=k 表示系统中现有j R 类资源k 个。
(b)最大需求矩阵Max 这是一个n m ?的矩阵，它定义了系统中n 个进程中的每一个进程对m 类资源的最大需求。
如果Max(i,j)=k ，表示进程i 需要j R 类资源的最大数目为k 。
(c)分配矩阵Allocation 这是一个n m ?的矩阵，它定义了系统中每一类资源当前已分配该每一进程的资源数。
如果Allocation(i,j)=k,表示进程i 当前已分得j R 类资源的数目为k 。 (d)分配矩阵Need
这是一个n m ?的矩阵，用以表示每一个进程尚需的各类资源数。 如果Need(i,j)=k 表示进程i 还需要j R 类资源k 个，方能完成其任务。 上述三个矩阵存在如下关系：
Need(i,j)=Max(i,j)-Allocation(i,j)
(2)银行家算法
设i quest Re 是进程i P 的请求向量。如果i quest Re [j]=k ，表示进程i P 需要k 个j R 类的资源。当i P 发出资源请求后，系统按下述步骤进行检查：
① 如果i i Need quest ≤Re ,则转向步骤②；否则，认为出错，因为它所需要
的资源数已超过它所宣布的最大值。
② 如果Available Re ≤i quest ，则转向步骤③；否则，表示系统中尚无足够的的资源，i P 必须等待。
③系统试探把要求的资源分配给进程i P ，并修改下面数据结构中的数值：
Available =：Available- i quest Re ；
i i i Request Allocation Allocation +=：；
i i i Request - Need Need =：；
④系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程i P ，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程i P 等待。
(3)安全性算法
系统所执行的安全性算法描述如下： ①设置两个向量
(a)工作向量Work 。它表示系统可提供给进程继续运行所需要的各类资源数目，它含有m 个元素，执行安全算法开始时，Work:=Available 。
(b)Finish 。它表示系统是否有足够的资源分配给进程，使之运行完成，开始
时先做Finish[i] :=false ；当有足够资源分配给进程时，令 Finish[i] :=true 。
②从进程集合中找到一个能满足下列条件的进程： (a) Finish[i]:=false
(b) Work Need i ≤
如找到，执行步骤③；否则执行步骤④。
③当进程i P 获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work:=Work+Allocationi; Finish[i]:=true; go to step (2)
④如果所有进程的Finish[i]:=true ，则表示系统处于安全状态；否则，系统处于不安全状态。 6．参考算法 #include
#define MAX_PROCESS 32 //最大进程数
#define MAX_COURCE 64 //最大资源类别
int MAX_FACT_PROCESS; //实际总进程数
int MAX_FACT_COURCE; //实际资源类别数
int Available[MAX_COURCE]; //可利用资源向量
int Max[MAX_PROCESS][MAX_COURCE]; //最大需求矩阵
int Allocation[MAX_PROCESS][MAX_COURCE]; //分配矩阵
int Need[MAX_PROCESS][MAX_COURCE]; //需求矩阵
int Request_PROCESS; //发出请求的进程
int Request_COURCE; //被请求资源类别
int Request_COURCE_NEMBER; //请求资源数
struct COMP{
int value;
int num;
int next;
};
int flag=0;
void Read_Initiate(void){ //读入初始化文档
ifstream infile("Initiate.txt");
if(!infile){
cout<<"不能打开输入文件:"<<"Initiate.txt"<<'\n';
exit(1);
}
cout<<"开始读入初始化文档"<<'\n';
int ch;
int Array[MAX_PROCESS*MAX_COURCE*2];
int num=0;
while(infile>>ch)
Array[num++]=ch;
num=0;
MAX_FACT_COURCE=Array[num++];
for(int j=0;j Available[j]=Array[num++]; MAX_FACT_PROCESS=Array[num++]; for(int i=0;i for(int j=0;j Max[i][j]=Array[num++]; } infile.close(); } void Write_Initiate(void){ //写入初始化文档(分配资源ofstream outfile("Initiate.txt"); cout<<"不能打开初始化文档："<<'\n'; exit(1); } int Array[MAX_PROCESS*MAX_COURCE*2]; int num=0; Array[num++]=MAX_FACT_COURCE; for(int i=0;i Array[num++]=Available[i]; Array[num++]=MAX_FACT_PROCESS; for(i=0;i for(int j=0;j Array[num++]=Max[i][j]; num=0; outfile< for(i=0;i outfile< outfile<<'\n'< for(i=0;i for(int j=0;j outfile< outfile< } DWORD m_delay=3000; Sleep(m_delay); outfile.close(); cout<<"修改初始化文档成功!"< } void Allocated_list(void){ //读入已分配资源列表ifstream infile("Allocated_list.txt"); if(!infile){ cout<<"不能打开输入文件:"<<"Allocated_list.txt"<<'\n'; exit(1); } cout<<"开始读入已分配资源列表"<<'\n'; int ch,num=0; int Array[MAX_PROCESS*MAX_COURCE]; while(infile>>ch) Array[num++]=ch; num=0; for(int i=0;i for(int j=0;j Allocation[i][j]=Array[num++]; } void Set_Need(void){ //设置需求矩阵 cout<<"设置需求矩阵"<<'\n'; for(int i=0;i for(int j=0;j Need[i][j]=Max[i][j]-Allocation[i][j]; } void Read_Request(void){ //读入请求向量 ifstream infile("Request_list.txt"); if(!infile){ cout<<"不能打开输入文件:"<<"Request_list.txt"<<'\n'; exit(1); } cout<<"开始读入请求向量"<<'\n'; int Array[3]; int num=0,ch; while(infile>>ch) Array[num++]=ch; Request_PROCESS=Array[0]; Request_COURCE=Array[1]; Request_COURCE_NEMBER=Array[2]; infile.close(); } void Write_Allocation(void){ //修改资源分配列表(资源分配) ofstream outfile("Allocated_list.txt"); if(!outfile){ cout<<"不能打开资源分配列表："<<'\n'; exit(1); } for(int i=0;i for(int j=0;j outfile< outfile< } DWORD m_delay=3000; Sleep(m_delay); cout<<"修改资源分配列表成功!"< outfile.close(); } void Allocate_Source(void){ //开始分配(已通过扫描和安全性检测) cout<<'\n'<<"开始给第"< "< <<"类资源"< Write_Allocation(); DWORD m_delay=3000; Sleep(m_delay); cout<<'\n'<<"祝贺您，资源分配已成功!"< } void Test_Safty(){ //安全性检测 cout<<'\n'<<"进入安全性检测!"< int Work[MAX_COURCE]; for(int i=0;i Work[i]=Available[i]; } bool Finish[MAX_PROCESS][MAX_COURCE]; for(i=0;i for(int j=0;j Finish[i][j]=false; COMP Array[32]; for(i=0;i { Array[i].value=Need[i][Request_COURCE-1]; Array[i].num=i; } for(i=0;i for(int j=i+1;j if(Array[i].value>=Array[j].value){ int t; t=Array[j].value; Array[j].value=Array[i].value; Array[i].value=t; t=Array[j].num; Array[j].num=Array[i].num; Array[i].num=t; } else continue; } DWORD m_delay=3000; Sleep(m_delay); /*for(i=0;i for(int j=0;j cout< cout< } */ if(Finish[Request_PROCESS-1][Request_COURCE-1]==false&&Need[Request_PR OCESS-1][Request_COURCE-1]<=Work[Request_COURCE-1]) { Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Request_PRO CESS-1][Request_COURCE-1]; Finish[Request_PROCESS-1][Request_COURCE-1]=true; } else { cout<<"未通过安全性测试，不与以分配"< exit(0); } for(i=0;i if(Array[i].num==Request_PROCESS-1) continue; if(Array[i].num!=Request_PROCESS-1&&Finish[Array[i].num][Request_COURCE-1]==false&&Need[Array[i].num][Request_COURCE-1]<=Work[Request_COURCE -1]){ Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Array[i].num] [Request_COURCE-1]; Finish[Array[i].num][Request_COURCE-1]=true; } } for(i=0;i { if(Finish[i][Request_COURCE-1]==true) continue; else { cout<<"未通过安全性测试，不与以分配"< exit(0); } } cout<<'\n'<<"找到一个安全序列:"<<"P"< for(i=0;i if(Array[i].num==Request_PROCESS) continue; else cout<<"P"< } cout<<'\n'<<"已通过安全性测试!"< Allocate_Source(); } void RUN(void){ //执行银行家算法 cout<<"*************************************************"<<'\n'<<"点击1执行!" <<'\n'<<"点击2退出!" <<'\n'<<"*************************************************"< if(flag==2) exit(0); if(flag==1) { cout<<"开始扫描请求信息!"< DWORD m_delay=3000; Sleep(m_delay); if(Request_COURCE_NEMBER>Need[Request_PROCESS-1][Request_COURCE-1 ]) { cout<<'\n'<<"第"< cout<<"可是已超出该进程尚需的该类资源的最大数量,所以不予以分 配!!"< exit(0); } if(Request_COURCE_NEMBER>Available[Request_COURCE-1]) { cout<<'\n'<<"第"< cout<<"可是系统中尚无足够的资源,所以进入等待队列!!"< exit(0); } else{ Available[Request_COURCE-1]=Available[Request_COURCE-1]-Request_COURC E_NEMBER; Allocation[Request_PROCESS-1][Request_COURCE-1]=Allocation[Request_P ROCESS-1][Request_COURCE-1]+Request_COURCE_NEMBER; Need[Request_PROCESS-1][Request_COURCE-1]=Need[Request_PROCESS-1][Request_COURCE-1]-Request_COURCE_NEMBER; cout<<"扫描通过"< Sleep(m_delay); Test_Safty(); } } else { cout<<"输入错误,请重新输入!"<<'\n'; RUN(); } } void main(void){ Read_Initiate(); cout< for(int i=0;i cout< cout< for(i=0;i for(int j=0;j cout< cout< } DWORD m_delay=3000; Sleep(m_delay); cout<<"读入成功"<<'\n'; Allocated_list(); for(i=0;i for(int j=0;j cout< cout< } Sleep(m_delay); cout<<"读入成功"<<'\n'; Set_Need(); for(i=0;i for(int j=0;j cout< cout< } Sleep(m_delay); cout<<"设置成功"<<'\n'; Read_Request(); cout<<'\n'<<"第"< cout<<'\n'<<"读入成功"<<'\n'; RUN(); } 注:数组Array[I]表示第I+1个实际意义量需要创建三个txt文本。 1.Initiate.txt文本 3 3 3 2 //共有3类资源,Available[0]=3; Available[1]=3; Available[2]=2 5 //当前系统中有个进程 7 5 3 // Max[0][0]=7 3 2 2 //Max[1][1]=3 9 0 2 2 2 2 4 3 3 2.Allocated_list.txt文本 0 1 0 //Allocation[0][1]=1 2 0 0 3 0 2 2 1 1 0 0 2 3.Request_list.txt文本 2 1 1 //第2个进程请求第1类资源1个Request[1][0]=1 本程序假设当前时刻只有一个进程请求某一类资源n个. 若要满足某个进程当前时刻同时请求不止一类资源,则需要为最大需求矩阵Max,分配矩阵Allocation和需求矩阵Need增加维数,当然代码量也将大大增加,但是算法逻辑本身并无变化. 实验四操作系统内存结构 1．实验目的 (1)通过实验了解操作系统内存的使用，学习如何在应用程序中管理内存，体会Windows应用程序内存的简单性和自我保护能力。 (2)了解Windows 2000的内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。 2．实验预备知识 (1)阅读教材关于存储器管理和虚拟存储器管理的内容。 (2)熟悉Visual C++的简单使用。 (3) Windows 2000是32位的操作系统，它使计算机CPU可以用32位地址对32位内存块进行操作。内存中的每一个字节都可以用一个32位的指针来寻址，这样，最大的存储空间就是32 2字节4000兆字节(4GB)，在Windows下运行的每一个应用程序都认为能独占4GB 内存了。显然，Windows在幕后将虚拟内存（virtual memory，VM）地址映射到了各进程的物理内存上。而所谓物理内存是指计算机的RAM和由Windows分配到用户驱动器根目录上的换页文件。物理内存完全由系统管理。 (4) Windows提供了一个API，即GetSystemInfo（），以便用户能检查系统中虚拟内存的一些特性。 (5)MSDN的使用。 3．实验环境 （1）一台运行Windows 2000 professional操作系统的计算机。 （2）选用turbo c、visual c++、Delphi、c++ builder或visual basic 等任何一种语言，建议用visual c++。 4．实验时间：2个机时。 5．实验内容 实验步骤如下： (1)登陆操作系统（Windows 2000、Windows XP或Windows Sever 2003） (2)运行Visual C++6.0（或Visual C++.NET） (3)在工具栏击“File\new\projects”，选择”Win32 Console Application”，并添 上“Project name”，选择“OK”，然后选择“A simple application”，选择 “Finish”。 (4)编写程序，然后程序进行编译，并运行。 (5)试记录以下结果： ①虚拟内存每页容量是多少？ ②最小应用地址是多少？ ③最大应用地址是多少？ ④当前可供应用程序使用的内存空间是多少？ ⑤当前计算机的实际内存是多大？ 提示：可供应用程序使用的内存空间实际上已经减去了开头与结尾两个64KB 的保护区。虚拟内存空间的64KB保护区是防止编程错误的一种Windows方式。任何对内存中这一区域的访问（读、写、执行）都将引发一个错误陷阱，从而导致错误并终止程序的执行。也就是说，假如用户有一个NULL指针（地 址为0），但仍试图在此之前很近的地址处使用另一个指针，这将因为试图从更低的保留区域读写数据，从而产生意外错误并终止程序的执行。 6．参考算法 #include "stdafx.h" #include #include #include #include #pragma comment(lib,"shlwapi.lib") int main() { //首先获得系统信息 SYSTEM_INFO si; ::ZeroMemory(&si,sizeof(si)); ::GetSystemInfo(&si); //使用外壳辅助程序对一些尺寸进行格式化 TCHAR szPageSize[MAX_PATH]; ::StrFormatByteSize(si.dwPageSize,szPageSize,MAX_PATH); DWORD dwMemSize=(DWORD)si.lpMaximumApplicationAddress-(DWORD)si.lpMinimum ApplicationAddress; TCHAR szMemSize[MAX_PATH]; ::StrFormatByteSize(dwMemSize,szMemSize,MAX_PATH); //将内存信息显示出来 std::cout<<"Virtual memory page size:"< < std::cout.fill('0'); std::cout<<"Minimum application address:0X" < <<(DWORD)si.lpMinimumApplicationAddress < std::cout<<"Maximum application address:0X" < <<(DWORD)si.lpMaximumApplicationAddress < std::cout<<"Total available virtual memory" < } 参考结果如下： Virtual memory page size:4.00 KB Minimum application address:0X00010000 Maximum application address:0X7ffeffff Total available virtual memory1.99 GB 实验五简单文件系统的实现 1．实验目的 通过一个简单的文件系统的设计，加深对文件系统存储空间的管理、文件的 结构、目录结构和文件操作等内部功能和实现过程的理解。 2．实验预备内容 （1）操作系统教材中有关文件管理的章节。 （2）了解DOS操作系统有关文件的操作。 （3）数据结构中有关队列的内容。 3．实验环境 （1）一台运行Windows 2000 professional操作系统的计算机。 （2）选用turbo c、visual c++、Delphi、c++ builder或visual basic 等任何一种语言，建议用visual c++。 4．实验时间：2个机时。 5．实验内容 （1）模仿DOS操作系统设计一个文件系统，能实现一些功能： cd 进入文件目录，并置为当前目录 create 创建文件 del 删除文件 dir 文件和目录列表 lsall 显示从根目录开始的所有目录和文件及其层次结点 md 创建目录 rd 删除目录 ren 文件更名 exit 退出文件系统 （2）列目录时要列出目录名和文件名，文件名要列出文件名和文件占用字节数。 （3）要求格式参考DOS操作系统文件显示格式，对这些内容感兴趣的同学，可在系统要求的基础上进行扩充。 6．参考算法 filesys.h #include #include"string.h" #include"stdlib.h" #define MaxSize 100 //目录和文件的结构定义 struct DirectoryNode { char name[50];//目录或文件名字 int type;//0代表目录,1代表普通文件 struct DirectoryNode *next;//指向下一个兄弟结点的指针 struct DirectoryNode *preDirFile;//指向父结点的指针 struct DirectoryNode *subFile;//指向第一个子结点的指针 int size; }; //在lsall函数中要用到的相应的队列的数据结构 struct DataType { DirectoryNode *DirFile; char name[50]; };//包含一个指向目录的指针和名字 /***********队列定义*********************/ struct Tp//队列结构的实现 { DataType data[MaxSize]; int front,rear;//分别表示队列的头结点和尾结点 }; void InitCycQueue(Tp *sq)//队列初始化 { sq->front=0; sq->rear=0; } int EncycQueue(Tp *sq,DataType data)//在队列中增加元素{ if((sq->rear+1)%MaxSize==sq->front) { printf("%sQueue is full!"); return 0; } else { sq->rear=(sq->rear+1)%MaxSize; sq->data[sq->rear]=data; return 1; } } DataType OutCycQueue(Tp *sq)//从队列中删除一个元素{ if(sq->front==sq->rear) printf("%sQueue is empty!"); else { sq->front=(sq->front+1)%MaxSize; 计算机操作系统知识点总结 导读：我根据大家的需要整理了一份关于《计算机操作系统知识点总结》的内容，具体内容：计算机操作系统考试是让很多同学都觉得头疼的事情，我们要怎么复习呢?下面由我为大家搜集整理了计算机操作系统的知识点总结，希望对大家有帮助!：第一章1、操作系统的定义、目标... 计算机操作系统考试是让很多同学都觉得头疼的事情，我们要怎么复习呢?下面由我为大家搜集整理了计算机操作系统的知识点总结，希望对大家有帮助! ：第一章 1、操作系统的定义、目标、作用 操作系统是配置在计算机硬件上的第一层软件，是对硬件系统的首次扩充。设计现代OS的主要目标是：方便性，有效性，可扩充性和开放性. OS的作用可表现为： a. OS作为用户与计算机硬件系统之间的接口;(一般用户的观点) b. OS作为计算机系统资源的管理者;(资源管理的观点) c. OS实现了对计算机资源的抽象. 2、脱机输入输出方式和SPOOLing系统(假脱机或联机输入输出方式)的联系和区别 脱机输入输出技术(Off-Line I/O)是为了解决人机矛盾及CPU的高速性和I/O设备低速性间的矛盾而提出的.它减少了CPU的空闲等待时间，提高了I/O速度. 由于程序和数据的输入和输出都是在外围机的控制下完成的，或者说，它们是在脱离主机的情况下进行的，故称为脱机输入输出方式;反之，在主机的直接控制下进行输入输出的方式称为联机(SPOOLing)输入输出方式 假脱机输入输出技术也提高了I/O的速度，同时还将独占设备改造为共享设备，实现了虚拟设备功能。 3、多道批处理系统需要解决的问题 处理机管理问题、内存管理问题、I/O设备管理问题、文件管理问题、作业管理问题 4、OS具有哪几个基本特征?它的最基本特征是什么? a. 并发性(Concurrence),共享性(Sharing),虚拟性(Virtual),异步性(Asynchronism). b. 其中最基本特征是并发和共享. c. 并发特征是操作系统最重要的特征，其它三个特征都是以并发特征为前提的。 5、并行和并发 并行性和并发性是既相似又有区别的两个概念，并行性是指两个或多个事件在同一时刻发生;而并发性是指两个或多少个事件在同一时间间隔内发生。 6、操作系统的主要功能，各主要功能下的扩充功能 a. 处理机管理功能： 进程控制，进程同步，进程通信和调度. b. 存储管理功能： 中南大学信息科学与工程学院实验报告 姓名：安磊 班级：计科0901 学号： 0909090310 指导老师：宋虹 目录 课程设计内容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------6 文件系统的层次结构和功能模块 ---------------------6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录-------------------------------------------------- 12 课程设计内容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在内存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统内核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小内核可编译至2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统内核，它仅仅包含了任务调度，任务管理，时间管理，内存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全 可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时内核，并在这个内核之上提供最基本的系统服务，如信号量，邮箱，消息队列，内存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图： #include "stdio.h" #include 第一章 ★1.操作系统的概念：通常把操作系统定义为用以控制和管理计算机系统资源方便用户使用的程序和数据结构的集合。★2.操作系统的基本类型：批处理操作系统、分时操作系统、实时操作系统、个人计算机操作系统、网络操作系统、分布式操作系统。 ①批处理操作系统 特点： 用户脱机使用计算机 成批处理 多道程序运行 优点： 由于系统资源为多个作业所共享，其工作方式是作业之间自动调度执行。并在运行过程中用户不干预自己的作业，从而大大提高了系统资源的利用率和作业吞吐量。 缺点： 无交互性，用户一旦提交作业就失去了对其运行的控制能力；而且是批处理的，作业周转时间长，用户使用不方便。 批处理系统中作业处理及状态 ②分时操作系统(Time Sharing OS) 分时操作系统是一个联机的多用户交互式的操作系统，如UNIX是多用户分时操作系统。 分时计算机系统：由于中断技术的使用，使得一台计算机能连接多个用户终端，用户可通过各自的终端使用和控制计算机，我们把一台计算机连接多个终端的计算机系统称为分时计算机系统，或称分时系统。 分时技术：把处理机的响应时间分成若于个大小相等（或不相等）的时间单位，称为时间片（如100毫秒），每个终端用户获得CPU，就等于获得一个时间片，该用户程序开始运行，当时间片到（用完），用户程序暂停运行，等待下一次运行。 特点： 人机交互性好：在调试和运行程序时由用户自己操作。 共享主机：多个用户同时使用。 用户独立性：对每个用户而言好象独占主机。 ③实时操作系统(real-time OS) 实时操作系统是一种联机的操作系统，对外部的请求，实时操作系统能够在规定的时间内处理完毕。 特点： 有限等待时间 有限响应时间 用户控制 可靠性高 系统出错处理能力强 设计实时操作系统要考虑的一些因素： （1）实时时钟管理 （2）连续的人—机对话 （3）过载 (4) 高度可靠性和安全性需要采取冗余措施。 ④通用操作系统 同时兼有多道批处理、分时、实时处理的功能，或其中两种以上的功能。 ⑤个人计算机上的操作系统 中南大学信息科学与工程学院实验报告 ：安磊 班级：计科0901 学号： 0909090310 指导老师：宋虹 目录 课程设计容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------ 6 文件系统的层次结构和功能模块 --------------------- 6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录 -------------------------------------------------- 12 课程设计容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小核可编译至 2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统核，它仅仅包含了任务调度，任务管理，时间管理，存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时核，并在这个核之上提供最基本的系统服务，如信号量，，消息队列，存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图： 计算机操作系统内存分配实验报告记录 ————————————————————————————————作者：————————————————————————————————日期： 一、实验目的 熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。 二、实验内容和要求 主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。 可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。 实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。 三、实验主要仪器设备和材料 实验环境 硬件环境：PC或兼容机 软件环境：VC++ 6.0 四、实验原理及设计分析 某系统采用可变分区存储管理，在系统运行当然开始，假设初始状态下，可用的内存空间为640KB，存储器区被分为操作系统分区（40KB）和可给用户的空间区（600KB）。 （作业1 申请130KB、作业2 申请60KB、作业3 申请100KB 、作业2 释放 60KB 、作业4 申请 200KB、作业3释放100KB、作业1 释放130KB 、作业5申请140KB 、作业6申请60KB 、作业7申请50KB） 当作业1进入内存后，分给作业1（130KB），随着作业1、2、3的进入，分别分配60KB、100KB，经过一段时间的运行后，作业2运行完毕，释放所占内存。此时，作业4进入系统，要求分配200KB内存。作业3、1运行完毕，释放所占内存。此时又有作业5申请140KB，作业6申请60KB，作业7申请50KB。为它们进行主存分配和回收。 1、采用可变分区存储管理，使用空闲分区链实现主存分配和回收。 空闲分区链：使用链指针把所有的空闲分区链成一条链，为了实现对空闲分区的分配和链接，在每个分区的起始部分设置状态位、分区的大小和链接各个分区的前向指针，由状态位指示该分区是否分配出去了；同时，在分区尾部还设置有一后向指针，用来链接后面的分区；分区中间部分是用来存放作业的空闲内存空间，当该分区分配出去后，状态位就由“0”置为“1”。 设置一个内存空闲分区链，内存空间分区通过空闲分区链来管理，在进行内存分配时，系统优先使用空闲低端的空间。 设计一个空闲分区说明链，设计一个某时刻主存空间占用情况表，作为主存当前使用基础。初始化空间区和已分配区说明链的值，设计作业申请队列以及作业完成后释放顺序，实现主存的分配和回收。要求每次分配和回收后显示出空闲内存分区链的情况。把空闲区说明 《计算机操作系统》 实验指导书 （适合于计算机科学与技术专业） 湖南工业大学计算机与通信学院 二O一四年十月 前言 计算机操作系统是计算机科学与技术专业的主要专业基础课程，其实践性、应用性很强。实践教学环节是必不可少的一个重要环节。计算机操作系统的实验目的是加深对理论教学内容的理解和掌握，使学生较系统地掌握操作系统的基本原理，加深对操作系统基本方法的理解，加深对课堂知识的理解，为学生综合运用所学知识，在Linux环境下调用一些常用的函数编写功能较简单的程序来实现操作系统的基本方法、并在实践应用方面打下一定基础。要求学生在实验指导教师的帮助下自行完成各个操作环节，并能实现且达到举一反三的目的，完成一个实验解决一类问题。要求学生能够全面、深入理解和熟练掌握所学内容，并能够用其分析、设计和解答类似问题；对此能够较好地理解和掌握，并且能够进行简单分析和判断；能够熟练使用Linux用户界面；掌握操作系统中进程的概念和控制方法；了解进程的并发，进程之间的通信方式，了解虚拟存储管理的基本思想。同时培养学生进行分析问题、解决问题的能力；培养学生完成实验分析、实验方法、实验操作与测试、实验过程的观察、理解和归纳能力。 为了收到良好的实验效果，编写了这本实验指导书。在指导书中，每一个实验均按照该课程实验大纲的要求编写，力求紧扣理论知识点、突出设计方法、明确设计思路，通过多种形式完成实验任务，最终引导学生有目的、有方向地完成实验任务，得出实验结果。任课教师在实验前对实验任务进行一定的分析和讲解，要求学生按照每一个实验的具体要求提前完成准备工作，如：查找资料、设计程序、完成程序、写出预习报告等，做到有准备地上机。进行实验时，指导教师应检查学生的预习情况，并对调试过程给予积极指导。实验完毕后，学生应根据实验数据及结果，完成实验报告，由学习委员统一收齐后交指导教师审阅评定。 实验成绩考核： 实验成绩占计算机操作系统课程总评成绩的20%。指导教师每次实验对学生进行出勤考核，对实验效果作记录，并及时批改实验报告，综合评定每一次的实验成绩，在学期终了以平均成绩作为该生的实验成绩。有以下情形之一者，实验成绩为不及格： 1.迟到、早退、无故缺勤总共3次及以上者； 2.未按时完成实验达3次及以上者； 3.缺交实验报告2次及以上者。 1）选择题 （1）为多道程序提供的可共享资源不足时，可能出现死锁。但是，不适当的 _C__ 也可能产生死锁。 A. 进程优先权 B. 资源的线性分配 C. 进程推进顺序 D. 分配队列优先权 （2）采用资源剥夺法可以解除死锁，还可以采用 _B___ 方法解除死锁。 A. 执行并行操作 B. 撤消进程 C. 拒绝分配新资源 D. 修改信号量 （3）发生死锁的必要条件有四个，要防止死锁的发生，可以通过破坏这四个必要条件之一来实现，但破坏 _A__ 条件是不太实际的。 A. 互斥 B. 不可抢占 C. 部分分配 D. 循环等待 （4）为多道程序提供的资源分配不当时，可能会出现死锁。除此之外，采用不适当的_ D _ 也可能产生死锁。 A. 进程调度算法 B. 进程优先级 C. 资源分配方法 D. 进程推进次序 （5）资源的有序分配策略可以破坏 __D___ 条件。 A. 互斥使用资源 B. 占有且等待资源 C. 非抢夺资源 D. 循环等待资源 （6）在 __C_ 的情况下，系统出现死锁。 A. 计算机系统发生了重大故障 B. 有多个封锁的进程同时存在 C. 若干进程因竞争资源而无休止地相互等待他方释放已占有的资源 D. 资源数大大小于进程数或进程同时申请的资源数大大超过资源总数 （7）银行家算法在解决死锁问题中是用于 _B__ 的。 A. 预防死锁 B. 避免死锁 C. 检测死锁 D. 解除死锁 （8）某系统中有3个并发进程，都需要同类资源4个，试问该系统不会发生死锁的最少资源数是 _C__ 。 A. 12 B. 11 C. 10 D. 9 （9）死锁与安全状态的关系是 _A__ 。 A. 死锁状态一定是不安全状态 B. 安全状态有可能成为死锁状态 C. 不安全状态就是死锁状态 D. 死锁状态有可能是安全状态 （10）如果系统的资源有向图 _ D __ ，则系统处于死锁状态。 A. 出现了环路 B. 每个进程节点至少有一条请求边 C. 没有环路 D. 每种资源只有一个，并出现环路 （11）两个进程争夺同一个资源，则这两个进程 B 。 实验报告 课程名称：嵌入式系统 学院：信息工程 专业：电子信息工程 班级： 学生姓名： 学号： 指导教师： 开课时间：学年第一学期 实验名称：IO接口（跑马灯） 实验时间：11.16 实验成绩： 一、实验目的 1.掌握 STM32F4 基本IO口的使用。 2.使用STM32F4 IO口的推挽输出功能，利用GPIO_Set函数来设置完成对 IO 口的配置。 3.控制STM32F4的IO口输出，实现控制ALIENTEK 探索者STM32F4开发板上的两个LED实现一个类似跑马灯的效果。 二、实验原理 本次实验的关键在于如何控制STM32F4的IO口输出。IO主要由：MODER、OTYPER、OSPEEDR、PUPDR、ODR、IDR、AFRH和AFRL等8个寄存器的控制，并且本次实验主要用到IO口的推挽输出功能，利用GPIO_Set函数来设置，即可完成对IO口的配置。所以可以通过了开发板上的两个LED灯来实现一个类似跑马灯的效果。 三、实验资源 实验器材: 探索者STM32F4开发板 硬件资源: 1.DS0(连接在PF9) 2.DS1(连接在PF10) 四、实验内容及步骤 1.硬件设计 2.软件设计 （1）新建TEST工程，在该工程文件夹下面新建一个 HARDWARE文件夹，用来存储以后与硬件相关的代码。然后在 HARDWARE 文件夹下新建一个LED文件夹，用来存放与LED相关的代码。 （2）打开USER文件夹下的test.uvproj工程，新建一个文件，然后保存在 LED 文件夹下面，保存为 led.c，在led.c中输入相应的代码。 （3）采用 GPIO_Set 函数实现IO配置。LED_Init 调用 GPIO_Set 函数完成对 PF9 和 PF10 ALIENTEK 探索者 STM32F407 开发板教程 119 STM32F4 开发指南(寄存器版) 的模式配置，控制 LED0 和 LED1 输出 1（LED 灭），使两个 LED 的初始化。 （4）新建一个led.h文件，保存在 LED 文件夹下，在led.h中输入相应的代码。 3.下载验证 使用 flymcu 下载（也可以通过JLINK等仿真器下载），如图 1.2所示： 图1.2 运行结果如图1.3所示： 实验三进程与线程 问题： 进程是具有独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的独立单位，具有动态性、并发性、独立性、异步性和交互性。然而程序是静态的，并且进程与程序的组成不同，进程＝程序＋数据＋PCB，进程的存在是暂时的，程序的存在是永久的；一个程序可以对应多个进程，一个进程可以包含多个程序。当操作系统引入线程的概念后，进程是操作系统独立分配资源的单位，线程成为系统调度的单位，与同一个进程中的其他线程共享程序空间。 本次实验主要的目的是： （1）理解进程的独立空间； （2）加深对进程概念的理解，明确进程和程序的区别； （3）进一步认识并发执行的实质； （4）了解红帽子（Linux）系统中进程通信的基本原理。 （5）理解线程的相关概念。 要求： 1、请查阅资料，掌握进程的概念，同时掌握进程创建和构造的相关知识和线程创建和 构造的相关知识，了解C语言程序编写的相关知识； （1）进程： 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内 存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。 （2）进程的创建和构造: 进程简单来说就是在操作系统中运行的程序，它是操作系统资源管理的最小单位。但是进程是一个动态的实体，它是程序的一次执行过程。进程和程序的区别在于：进程是动态的，程序是静态的，进程是运行中的程序，而程序是一些保存在硬盘上的可执行代码。新的进程通过克隆旧的程序（当前进程）而建立。fork() 和clone()（对于线程）系统调用可用来建立新的进程。 （3）线程的创建和构造： 线程也称做轻量级进程。就像进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与独立的进程相比，进程中的线程之间的独立程度要小。它们共享内存、文件句柄和其他每个进程应有的状态。 线程的出现也并不是为了取代进程，而是对进程的功能作了扩展。进程可以支持多个线程，它们看似同时执行，但相互之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，但你必须小心，确保它们不会妨碍同一进程里的其他线程。 线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制，但与进程不同的是，同类的多个线程是共享同一块内存空间和一组系统资源的，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小得多，正因如此，线程也被称为轻型进程（light-weight process）。一个进程中可以包含多个线程。 2、理解进程的独立空间的实验内容及步骤 作业2 1.若1页大小为4KB，计算机地址总线为32位，则页号共有多少位？逻辑地址 空间最多包含多少页？逻辑地址60000在第几页？页内偏移是多少？若该页被装进物理块1280中，则物理地址是多少？ 解:所以页内偏移即页内地址占 12 位页号占 32-12=20 位逻辑地址空间最大页数为页 60000=(EA60)16=(1110 1010 0110 0000)2 其中低 12 二进制位为页内偏移，即(A60)16=2656。高 4 二进制位为页号，即(E)16=14。物理块号1280=(500)16 物理地址=(500A60)16=5245536. 2.假定当前磁头位于100号磁道，进程对磁道的请求序列依次为57，61，39， 20，88，161，139，38，175。当采用先来先服务和最短寻道时间优先算法时，总的移动的磁道数分别是多少？（请给出寻道次序和每步移动磁道数） 解：先来先服务最短寻道时间优先 43 +4+ 22+ 19+ 68+ 73+ 22+ 101 + 137 = 489 12 + 27 + 4 +18 + 1+ 18 + 119 + 22 + 14 = 235 。 3.设系统中有三种类型的资源（A，B，C）和五个进程（P1，P2，P3，P4，P5）， A资源的数量17，B资源的数量为5，C资源的数量为20。在T0时刻系统状态如下表所示。系统采用银行家算法来避免死锁。请回答下列问题： （1）T0时刻是否为安全状态？若是，请给出安全序列。 （2）若进程P4请求资源（2，0，1），能否实现资源分配？为什么？ （3）在（2）的基础上，若进程P1请求资源（0，2，0），能否实现资源分配？为什么？ 进程最大资源需求量已分配资源量系统剩余资源数量 A B C A B C A B C P1559212233 P2536402 P3******* P4425204 _* 南京邮电大学通信学院 实验报告 实验名称：基于ADS开发环境的程序设计 嵌入式Linux交叉开发环境的建立 嵌入式Linux环境下的程序设计 多线程程序设计 课程名称嵌入式系统B 班级学号 姓名 开课学期2016/2017学年第2学期 实验一基于ADS开发环境的程序设计 一、实验目的 1、学习ADS开发环境的使用； 2、学习和掌握ADS环境下的汇编语言及C语言程序设计； 3、学习和掌握汇编语言及C语言的混合编程方法。 二、实验内容 1、编写和调试汇编语言程序； 2、编写和调试C语言程序； 3、编写和调试汇编语言及C语言的混合程序； 三、实验过程与结果 1、寄存器R0和R1中有两个正整数，求这两个数的最大公约数，结果保存在R3中。 代码1：使用C内嵌汇编 #include printf("gcdnum:%d\n",a); return 0; } 代码2：使用纯汇编语言 AREA example1,CODE,readonly ENTRY MOV r0, #4 MOV r1, #9 start CMP r0, r1 SUBLT r1, r1, r0 SUBGT r0, r0, r1 BNE start MOV r3, r0 stop B stop END 2、寄存器R0 、R1和R2中有三个正整数，求出其中最大的数，并将其保存在R3中。 代码1：使用纯汇编语言 AREA examp,CODE,READONL Y ENTRY MOV R0,#10 MOV R1,#30 MOV R2,#20 Start CMP R0,R1 BLE lbl_a CMP R0,R2 MOVGT R3,R0 MOVLE R3,R2 B lbl_b lbl_a CMP R1,R2 MOVGT R3,R1 MOVLE R3,R2 lbl_b B . END 代码2：使用C内嵌汇编语言 #include 操作系统实验报告 学院：计算机与通信工程学院 专业：计算机科学与技术 班级： 学号： 姓名： 指导教师： 成绩： 2014年 1 月 1 日 实验一线程的状态和转换（5分） 1 实验目的和要求 目的：熟悉线程的状态及其转换，理解线程状态转换与线程调度的关系。 要求： （1）跟踪调试EOS线程在各种状态间的转换过程，分析EOS中线程状态及其转换的相关源代码； （2）修改EOS的源代码，为线程增加挂起状态。 2 完成的实验内容 2.1 EOS线程状态转换过程的跟踪与源代码分析 （分析EOS中线程状态及其转换的核心源代码，说明EOS定义的线程状态以及状态转换的实现方法；给出在本部分实验过程中完成的主要工作，包括调试、跟踪与思考等） 1.EOS 准备了一个控制台命令“loop ”，这个命令的命令函数是 ke/sysproc.c 文件中的ConsoleCmdLoop 函数（第797行，在此函数中使用 LoopThreadFunction 函数（第755 行）创建了一个优先级为 8 的线程（后面简称为“loop 线程”），该线程会在控制台中不停的（死循环）输出该线程的ID和执行计数，执行计数会不停的增长以表示该线程在不停的运行。loop命令执行的效果可以参见下图： 2. 线程由阻塞状态进入就绪状态 （1）在虚拟机窗口中按下一次空格键。 （2）此时EOS会在PspUnwaitThread函数中的断点处中断。在“调试”菜单中选择“快速监视”，在快速监视对话框的表达式编辑框中输入表达式“*Thread”，然后点击“重新计算”按钮，即可查看线程控制块（TCB）中的信息。其中State域的值为3（Waiting），双向链表项StateListEntry的Next和Prev指针的值都不为0，说明这个线程还处于阻塞状态，并在某个同步对象的等待队列中；StartAddr域的值为IopConsoleDispatchThread，说明这个线程就是控制台派遣线程。 （3）关闭快速监视对话框，激活“调用堆栈”窗口。根据当前的调用堆栈，可以看到是由键盘中断服务程序（KdbIsr）进入的。当按下空格键后，就会发生键盘中断，从而触发键盘中断服务程序。在该服务程序的最后中会唤醒控制台派遣线程，将键盘事件派遣到活动的控制台。 （4）在“调用堆栈”窗口中双击PspWakeThread函数对应的堆栈项。可以看到在此函数中连续调用了PspUnwaitThread函数和PspReadyThread函数，从而使处于阻塞状态的控制台派遣线程进入就绪状态。 （5）在“调用堆栈”窗口中双击PspUnwaitThread函数对应的堆栈项，先来看看此函数是如何改变线程状态的。按F10单步调试直到此函数的最后，然后再从快速监视对 操作系统习题集 参考教材： 汤小丹等编著，计算机操作系统（第三版），西安电子科技大学出版社，2007年版； 何炎祥等编著，计算机操作系统，清华大学出版社，2005年版； 邹恒明著，计算机的心智操作系统之哲学原理，机械工业出版社，2009年4月。 第一章操作系统引论 1.1 选择题 1．下列哪一条是在操作系统设计中引入多道程序技术的好处？ A. 使并发执行成为可能 B. 简化操作系统的实现 C. 减少对内存容量的需求 D. 便于实施存储保护 2．Windows XP属于下列哪一类操作系统？ A. 单用户单任务 B. 单用户多任务 C. 多用户 D. 批处理 3．下列哪一条不是批处理系统的优点？D A. 吞吐量大 B. 资源利用率高 C. 系统开销小 D. 响应及时 4．能及时处理由过程控制反馈的数据并作出响应的操作系统是（） A、分时系统 B、网络系统 C、实时系统 D、批处理系统 5．UNIX系统是一个__________操作系统。 A、单用户 B、单用户多任务 C、多用户多任务 D、多用户单任务 6．在分时系统中，当用户数一定时，影响响应时间的主要因素是＿＿。 A、时间片 B、调度算法 C、存储分配方式 D、作业的大小 7．Windows NT属于哪一类操作系统？ A、单用户单任务 B、单用户多任务 C、单道批处理 D、多用户 8．多道程序设计技术是指：多道程序可同时进入A ，在A 的位置B ，为使多道进程并发执行必须为每个用户作业创建进程，批处理系统由C 创建，而分时系统由D 创建。 选择答案： （1）内存（2）系统（3）固定（4）不定（5）进程调度（6）中级调度 （7）作业调度（8）输入进程（9）系统调用（10）命令解释进程 1.2 填空题 1．在手工操作阶段，操作员在进行装卸卡片或磁带等手工操作时，CPU处于空闲等待，我们称这种现象为。 2．多道批处理系统的特征为。 3．批量处理系统的缺点为；。 嵌入式系统实验实验报告 一、实验目的 1.基本实验 . Word 资料搭建PXA270嵌入式LINUX开发软硬件环境；安装LINUX操 作系统；安装与配置建立宿主机端交叉编译调试开发环境；配置宿主机 PC 机端的minicom（或超级终端）、TFTP服务、NFS服务，使宿主PC机与PXA270开发板可以通过串口通讯，并开通TFTP 和NFS服务。 2.人机接口 键盘驱动；LCD控制；触摸屏数据采集与控制实验； 3.应用实验 完成VGA显示；Web服务器实验；网络文件传输实验；多线程应用实验。 4.扩展应用实验 完成USB摄像头驱动与视频采集；GPS实验；GSM/GPRS通讯；视频播放移植；USB蓝牙设备无线通讯；NFS文件服务器；蓝牙视频文件服务器。 5.QT实验 完成基本嵌入式图形开发环境搭建；“Hello world！”QT初探；创建一个窗口并添加按钮；对象通信：Signal和Slot；菜单和快捷键；工具条和状态栏；鼠标和键盘事件；对话框；QT的绘图；俄罗斯方块；基于QT的GSM手机在嵌入式LINUX下的设计与实现。 二、实验内容 1.人机接口实验 实验十九键盘驱动实验 ?实验目的：矩阵键盘驱动的编写 ?实验内容：矩阵键盘驱动的编写 ?作业要求：完成键盘加减乘除运算 ?实验作业源码及注释： #INCLUDE 实验4 进程控制 1、实验目的 （1）通过对WindowsXP进行编程，来熟悉和了解系统。 （2）通过分析程序，来了解进程的创建、终止。 2、实验工具 （1）一台WindowsXP操作系统的计算机。 （2）计算机装有Microsoft Visual Studio C++6.0专业版或企业版。 3、预备知识 （3）·CreateProcess（）调用：创建一个进程。 （4）·ExitProcess（）调用：终止一个进程。 4、实验编程 （1）编程一利用CreateProcess()函数创建一个子进程并且装入画图程序(mspaint.exe)。阅读该程序,完成实验任务。源程序如下： # include < stdio.h > # include < windows.h > int main(VOID) ﹛STARTUPINFO si; PROCESS INFORMA TION pi; ZeroMemory(&si,sizeof(si)); Si.cb=sizeof(si); ZeroMemory(&pi,sizeof(pi)); if(!CreateProcess(NULL, “c: \ WINDOWS\system32\ mspaint.exe”, NULL, NULL, FALSE, 0, NULL, NULL, &si,&pi)) ﹛fprintf(stderr,”Creat Process Failed”); return—1; ﹜ WaitForSingleObject(pi.hProcess,INFINITE); Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜ 第3章处理机调度1）选择题 （1）在分时操作系统中，进程调度经常采用_D_ 算法。 A. 先来先服务 B. 最高优先权 C. 随机 D. 时间片轮转 （2）_B__ 优先权是在创建进程时确定的，确定之后在整个进程运行期间不再改变。 A. 作业 B. 静态 C. 动态 D. 资源 （3）__A___ 是作业存在的惟一标志。 A. 作业控制块 B. 作业名 C. 进程控制块 D. 进程名 （4）设有四个作业同时到达，每个作业的执行时间均为2小时，它们在一台处理器上按单道方式运行，则平均周转时间为_ B_ 。 A. l小时 B. 5小时 C. 2.5小时 D. 8小时 （5）现有3个同时到达的作业J1、J2和J3，它们的执行时间分别是T1、T2和T3，且T1＜T2＜T3。系统按单道方式运行且采用短作业优先算法，则平均周转时间是_C_ 。 A. T1+T2+T3 B. (T1+T2+T3)/3 C. (3T1+2T2+T3)/3 D. (T1+2T2+3T3)/3 （6）__D__ 是指从作业提交给系统到作业完成的时间间隔。 A. 运行时间 B. 响应时间 C. 等待时间 D. 周转时间 （7）下述作业调度算法中，_ C_调度算法与作业的估计运行时间有关。 A. 先来先服务 B. 多级队列 C. 短作业优先 D. 时间片轮转 2）填空题 （1）进程的调度方式有两种，一种是抢占(剥夺)式，另一种是非抢占(非剥夺)式。 （2）在_FCFS_ 调度算法中，按照进程进入就绪队列的先后次序来分配处理机。 （3）采用时间片轮转法时，时间片过大，就会使轮转法转化为FCFS_ 调度算法。 （4）一个作业可以分成若干顺序处理的加工步骤，每个加工步骤称为一个_作业步_ 。 （5）作业生存期共经历四个状态，它们是提交、后备、运行和完成。 （6）既考虑作业等待时间，又考虑作业执行时间的调度算法是_高响应比优先____ 。 3）解答题 （1）单道批处理系统中有4个作业，其有关情况如表3-9所示。在采用响应比高者优先调度算法时分别计算其平均周转时间T和平均带权周转时间W。（运行时间为小时，按十进制计算） 表3-9 作业的提交时间和运行时间 郑州航空工业管理学院 嵌入式系统实验报告 （修订版） 20 – 20第学期 赵成，张克新 院系： 姓名： 专业： 学号： 电子通信工程系 2014年3月制 实验一ARM体系结构与编程方法 一、实验目的 了解ARM9 S3C2410A嵌入式微处理器芯片的体系结构，熟悉ARM微处理器的工作模式、指令状态、寄存器组及异常中断的概念，掌握ARM指令系统，能在ADS1.2 IDE中进行ARM汇编语言程序设计。 二、实验内容 1．ADS1.2 IDE的安装、环境配置及工程项目的建立； 2．ARM汇编语言程序设计（参考附录A）： （1）两个寄存器值相加； （2）LDR、STR指令操作； （3）使用多寄存器传送指令进行数据复制； （4）使用查表法实现程序跳转； （5）使用BX指令切换处理器状态； （6）微处理器工作模式切换； 三、预备知识 了解ARM嵌入式微处理器芯片的体系结构及指令体系；熟悉汇编语言及可编程微处理器的程序设计方法。 四、实验设备 1. 硬件环境配置 计算机：Intel(R) Pentium(R) 及以上； 内存：1GB及以上； 实验设备：UP-NETARM2410-S嵌入式开发平台，J-Link V8仿真器； 2. 软件环境配置 操作系统：Microsoft Windows XP Professional Service Pack 2； 集成开发环境：ARM Developer Suite (ADS) 1.2。 五、实验分析 1．安装的ADS1.2 IDE中包括和两个软件组件。在ADS1.2中建立类型的工程，工程目标配置为；接着，还需要对工程进行、及链接器设置；最后，配置仿真环境为仿真方式。 2．写出ARM汇编语言的最简程序结构，然后在代码段中实现两个寄存器值的加法运算，给出运算部分相应指令的注释。 ; 文件名：计算机操作系统知识点总结
嵌入式操作系统实验报告
操作系统实验1
计算机操作系统知识点总结一
嵌入式操作系统实验报告
计算机操作系统内存分配实验报告记录
《计算机操作系统》实验指导书
计算机操作系统习题及答案
嵌入式系统实验报告
计算机操作系统实验四
计算机操作系统作业及答案
南邮嵌入式系统B实验报告2016年度-2017年度-2
计算机操作系统 实验报告
计算机操作系统习题集
嵌入式系统实验实验报告
操作系统原理实验四
计算机操作系统习题及答案
嵌入式系统实验报告
相关主题
文本预览