操作系统实验报告_实验四
实验四：进程管理（二）
实验内容:
1．编写一个程序，打印进程的如下信息：进程标识符，父进程标识符，真实用户ID，有效用户ID，真实用户组ID，有效用户组ID。并分析真实用户ID和有效用户ID的区别。
源代码及结果：
真实用户ID和有效用户ID的区别：
真实用户ID：这个ID就是我们登陆unix系统时的身份ID。
有效用户ID：定义了操作者的权限。有效用户ID是进程的属性，决定了该进程对文件的访问权限。
2．阅读如下程序，编译并运行，分析进程执行过程的时间消耗（总共消耗的时间和CPU 消耗的时间），并解释执行结果。再编写一个计算密集型的程序替代grep，比较两次时间的花销。注释程序主要语句。
/* process using time */
#include
#include
#include
#include
#include
void time_print(char *,clock_t);
int main(void){
//取得进程运行相关的时间
clock_t start,end;
struct tms t_start,t_end;
start = times(&t_start);
system(“grep the /usr/doc/*/* > /dev/null 2> /dev/null”);
/*command >/dev/null的作用是将是command命令的标准输出丢弃，而标准错误输出还是在屏幕上。一般来讲标准输出和标准错误输出都是屏幕，因此错误信息还是会在屏幕上输出。>/dev/null 2> /dev/null 标准输出与标准错误输出都会被丢弃*/ // 0 1 2 标准输入标准输出错误输出
// > 将信息放到该文件null中
end=times(&t_end);
time_print(“elapsed”,end-start);
puts(“parent times”);
time_print(“\tuser CP U”,t_end.tms_utime);
time_print(“\tsys CPU”,t_end.tms_stime);
puts(“child times”);
time_print(“\tuser CPU”,t_end.tms_cutime);
time_print(“\tsys CPU”,t_end.tms_cstime);
exit(EXIT_SUCCESS);
}
void time_print(char *str, clock_t time)
{
long tps = sysconf(_SC_CLK_TCK);
/*函数sysconf()的作用为将时钟滴答数转化为秒数，_SC_CLK_TCK 为定义每秒钟
有多少个滴答的宏*/
printf(“%s: %6.2f secs\n”,str,(float)time/tps);
}
程序运行结果：
因为该程序计算量很小，故消耗的时间比较少，CPU消耗时间均为0.00secs不足为奇。而进程的执行时间等于用户CPU时间和系统CPU时间加从硬盘读取数据时间之和。
密集型的程序替代grep：
更改为计算密集型的之后就较容易观察出消耗时间的差异。
3．阅读下列程序，编译并多次运行，观察执行输出次序，说明次序相同（或不同）的原因；观察进程ID，分析进程ID的分配规律。总结fork()的使用方法。注释程序主要语句。
/* fork usage */
#include
#include
#include
int main(void)
{
pid_t child;
if((child=fork())==-1){
perror(“fork”);
exit(EXIT_FAILURE);
}else if(child==0){
puts(“in child”);
printf(“\tchild pid = %d\n”,getpid());
printf(“\tchild ppid = %d\n”,getppid());
exit(EXIT_SUCCESS);
}else{
puts(“in parent”);
printf(“\tparent pid = %d\n”,getpid());
printf(“\tparent ppid = %d\n”,getppid());
}
exit(EXIT_SUCCESS);
}
程序运行结果：
（？）创建进程ID开始时一般随机分配，但若多次运行，或创建子进程时，会顺序分配内存。此外，当父进程结束时，子进程尚未结束，则子进程的父进程ID变为1。
fork()函数的实质是一个系统调用(和write函数类似)，其作用是创建一个新的进程，当一个进程调用它,完成后就出现两个几乎一模一样的进程，其中由fork()创建的新进程被称为子进
程，而原来的进程称为父进程。子进程是父进程的一个拷贝，即子进程从父进程得到了数据段和堆栈的拷贝，这些需要分配新的内存；而对于只读的代码段，通常使用共享内存方式进行访问。
4．阅读下列程序，编译并运行，等待或者按^C，分别观察执行结果并分析，注释程序主要语句。flag有什么作用？通过实验说明。
/* usage of kill,signal,wait */
#include
#include
#include
#include
int flag;
void stop(); //自定义函数，使flag=0，供signal调用
int main(void){
int pid1,pid2;
signal(3,stop); // signal()依参数3指定的信号编号来设置该信号的处理函数
while((pid1=fork()) ==-1); //程序等待成功创建子进程事件的发生
if(pid1>0){
//当前进程为父进程
while((pid2=fork()) ==-1);
if(pid2>0){
//当前进程为父进程，父进程发出两个中断信号Kill子进程
flag=1;
sleep(5);
kill(pid1,16); //将16指定的信号传给进程ID为pid1 的进程
kill(pid2,17); //将17指定的信号传给进程ID为pid2 的进程
wait(0); //暂时停止目前进程的执行，直到有信号来到或子进程结束
wait(0);
printf(“\n parent is killed\n”);
exit(EXIT_SUCCESS);
}else{
//当前进程为子进程，则发送子进程kill信号，杀死该子进程2 flag=1;
signal(17,stop);
printf(“\n child2 is killed by parent\n”);
exit(EXIT_SUCCESS);
}
}else{
//当前进程为子进程，则发送子进程kill信号，杀死该子进程1 flag=1;
signal(16,stop);
printf(“\n child1 is killed by parent\n”);
exit(EXIT_SUCCESS);
}
}
void stop(){
flag = 0;
}
程序运行结果：
每个进程（父进程，子进程）都有一个flag，起状态标志作用，flag=1时，表示进程在运行，flag=0，表示进程结束。
5．编写程序，要求父进程创建一个子进程，使父进程和个子进程各自在屏幕上输出一些信息，但父进程的信息总在子进程的信息之后出现。
程序源代码：
程序运行结果：
6．编写程序，要求父进程创建一个子进程，子进程执行shell命令find / -name hda* 的功能，子进程结束时由父进程打印子进程结束的信息。执行中父进程改变子进程的优先级。
程序源代码：
程序运行结果：
7．/**编写程序，要求父进程创建一个子进程，子进程对一个50*50的字符数组赋值，由父进程改变子进程的优先级，观察不同优先级进程使用CPU的时间。*/
8．查阅Linux系统中struct task_struct 的定义，说明每项成员的作用。
注：search in /usr/src/linux-2.6/include/linux/sched.h
广义上，所有的进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。每个进程在内核中都有一个进程控制块(PCB)来维护进程相关的信息,Linux内核的进程控制块是task_struct结构体。task_struct是Linux内核的一种数据结构，它会被装载到RAM里并且包含着进程的信息。每个进程都把它的信息放在task_struct 这个数据结构里，task_struct 包含了这些内容：
（1）标示符：描述本进程的唯一标示符，用来区别其他进程。
（2）状态：任务状态，退出代码，退出信号等。
（3）优先级：相对于其他进程的优先级。
（4）程序计数器：程序中即将被执行的下一条指令的地址。
（5）内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针。
（6）上下文数据：进程执行时处理器的寄存器中的数据。
（7）I／O状态信息：包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
（8）记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号。
……
保存进程信息的数据结构叫做task_struct，并且可以在include/linux/sched.h 里找到它。
所有运行在系统里的进程都以task_struct 链表的形式存在内核里。进程的信息可以通过/proc 系统文件夹查看。
task_struct一些字段的介绍：
1. 调度数据成员
(1) volatile long states;
表示进程的当前状态
(2) unsigned long flags;
进程标志
(3) long priority;
进程优先级。优先级可通过系统调用sys_setpriorty改变。
(4) unsigned long rt_priority;
rt_priority给出实时进程的优先级，rt_priority+1000给出进程每次获取CPU后可使用的时间(同样按jiffies计)。实时进程的优先级可通过系统调用sys_sched_setscheduler()改变(见kernel/sched.c)。
(5) long counter;
在轮转法调度时表示进程当前还可运行多久。在进程开始运行是被赋为priority的值，以后每隔一个tick(时钟中断)递减1，减到0时引起新一轮调度。重新调度将从run_queue队列选出counter值最大的就绪进程并给予CPU使用权，因此counter起到了进程的动态优先级的作用(priority则是静态优先级)。
(6) unsigned long policy;
该进程的进程调度策略，可以通过系统调用sys_sched_setscheduler()更改(见kernel/sched.c)。调度策略有:
?SCHED_OTHER 0 非实时进程，基于优先权的轮转法(round robin)。
?SCHED_FIFO 1 实时进程，用先进先出算法。
?SCHED_RR 2 实时进程，用基于优先权的轮转法。
2. 信号处理
(1) unsigned long signal;
进程接收到的信号。每位表示一种信号，共32种。置位有效。
(2) unsigned long blocked;
进程所能接受信号的位掩码。置位表示屏蔽，复位表示不屏蔽。
(3) struct signal_struct *sig;
因为signal和blocked都是32位的变量，Linux最多只能接受32种信号。对每种信号，各进程可以由PCB的sig属性选择使用自定义的处理函数，或是系统的缺省处理函数。指派各种信息处理函数的结构定义在include/linux/sched.h中。对信号的检查安排在系统调用结束后，以及“慢速型”中断服务程序结束后(IRQ#_interrupt()。
3. 进程队列指针
(1) struct task_struct *next_task，*prev_task;
所有进程(以PCB的形式)组成一个双向链表。next_task和就是链表的前后指针。链表的头和尾都是init_task(即0号进程)。
(2) struct task_struct *next_run，*prev_run;
由正在运行或是可以运行的，其进程状态均为TASK_RUNNING的进程所组成的一个双向循环链表，即run_queue就绪队列。该链表的前后向指针用next_run和prev_run，链表的头和尾都是init_task(即0号进程)。
(3) struct task_struct *p_opptr，*p_pptr;和struct task_struct *p_cptr，*p_ysptr，*p_osptr;
以上分别是指向原始父进程(original parent)、父进程(parent)、子进程(youngest child)及新老兄弟进程(younger sibling，older sibling)的指针。
4. 进程标识
(1) unsigned short uid，gid;
uid和gid是运行进程的用户标识和用户组标识。
(2) int groups[NGROUPS];
与多数现代UNIX操作系统一样，Linux允许进程同时拥有一组用户组号。在进程访问文件时，这些组号可用于合法性检查。
(3) unsigned short euid，egid;
euid和egid又称为有效的uid和gid。出于系统安全的权限的考虑，运行程序时要检查euid 和egid的合法性。通常，uid等于euid，gid等于egid。有时候，系统会赋予一般用户暂时拥有root的uid和gid(作为用户进程的euid和egid)，以便于进行运作。
(4) unsigned short fsuid，fsgid;
fsuid和fsgid称为文件系统的uid和gid，用于文件系统操作时的合法性检查，是Linux独特的标识类型。它们一般分别和euid和egid一致，但在NFS文件系统中NFS服务器需要作为一个特殊的进程访问文件，这时只修改客户进程的fsuid和fsgid。
(5) unsigned short suid，sgid;
suid和sgid是根据POSIX标准引入的，在系统调用改变uid和gid时，用于保留真正的uid 和gid。
(6) int pid，pgrp，session;
进程标识号、进程的组织号及session标识号，相关系统调用(见程序kernel/sys.c)有sys_setpgid、sys_getpgid、sys_setpgrp、sys_getpgrp、sys_getsid及sys_setsid几种。
(7) int leader;
是否是session的主管，布尔量。
5. 时间数据成员
(1) unsigned long timeout;
用于软件定时，指出进程间隔多久被重新唤醒。采用tick为单位。
(2) unsigned long it_real_value，it_real_iner;
用于itimer(interval timer)软件定时。采用jiffies为单位，每个tick使it_real_value减到0时向进程发信号SIGALRM，并重新置初值。初值由it_real_incr保存。具体代码见kernel/itimer.c 中的函数it_real_fn()。
(3) struct timer_list real_timer;
一种定时器结构(Linux共有两种定时器结构，另一种称作old_timer)。数据结构的定义在include/linux/timer.h中，相关操作函数见kernel/sched.c中add_timer()和del_timer()等。(4) unsigned long it_virt_value，it_virt_incr;
关于进程用户态执行时间的itimer软件定时。采用jiffies为单位。进程在用户态运行时，每个tick使it_virt_value减1，减到0时向进程发信号SIGVTALRM，并重新置初值。初值由it_virt_incr保存。具体代码见kernel/sched.c中的函数do_it_virt()。
(5) unsigned long it_prof_value，it_prof_incr;
同样是itimer软件定时。采用jiffies为单位。不管进程在用户态或内核态运行，每个tick使it_prof_value减1，减到0时向进程发信号SIGPROF，并重新置初值。初值由it_prof_incr 保存。具体代码见kernel/sched.c中的函数do_it_prof。
(6) long utime，stime，cutime，cstime，start_time;
以上分别为进程在用户态的运行时间、进程在内核态的运行时间、所有层次子进程在用户态的运行时间总和、所有层次子进程在核心态的运行时间总和，以及创建该进程的时间。
6. 信号量数据成员
(1) struct sem_undo *semundo;
进程每操作一次信号量，都生成一个对此次操作的undo操作，它由sem_undo结构描述。这些属于同一进程的undo操作组成的链表就由semundo属性指示。当进程异常终止时，系统会调用undo操作。sem_undo的成员semadj指向一个数据数组，表示各次undo的量。结构定义在include/linux/sem.h。
(2) struct sem_queue *semsleeping;
每一信号量集合对应一个sem_queue等待队列(见include/linux/sem.h)。进程因操作该信号量集合而阻塞时，它被挂到semsleeping指示的关于该信号量集合的sem_queue队列。反过来，semsleeping。sleeper指向该进程的PCB。
7. 进程上下文环境
(1) struct desc_struct *ldt;
进程关于CPU段式存储管理的局部描述符表的指针，用于仿真WINE Windows的程序。其他情况下取值NULL，进程的ldt就是arch/i386/traps.c定义的default_ldt。
(2) struct thread_struct tss;
任务状态段，其内容与INTEL CPU的TSS对应，如各种通用寄存器.CPU调度时，当前运行进程的TSS保存到PCB的tss，新选中进程的tss内容复制到CPU的TSS。结构定义在include/linux/tasks.h中。
(3) unsigned long saved_kernel_stack;
为MS-DOS的仿真程序(或叫系统调用vm86)保存的堆栈指针。
(4) unsigned long kernel_stack_page;
在内核态运行时，每个进程都有一个内核堆栈，其基地址就保存在kernel_stack_page中。8. 文件系统数据成员
(1) struct fs_struct *fs;
fs保存了进程本身与VFS的关系消息，其中root指向根目录结点，pwd指向当前目录结点，umask给出新建文件的访问模式(可由系统调用umask更改)，count是Linux保留的属性，如下页图所示。结构定义在include/linux/sched.h中。
(2) struct files_struct *files;
files包含了进程当前所打开的文件(struct file *fd[NR_OPEN])。在Linux中，一个进程最多只能同时打开NR_OPEN个文件。而且，前三项分别预先设置为标准输入、标准输出和出错消息输出文件。
(3) int link_count;
文件链(link)的数目。
Array. 内存数据成员
(1) struct mm_struct *mm;
在linux中，采用按需分页的策略解决进程的内存需求。task_struct的数据成员mm指向关于存储管理的mm_struct结构。其中包含了一个虚存队列mmap，指向由若干vm_area_struct 描述的虚存块。同时，为了加快访问速度，mm中的mmap_avl维护了一个A VL树。在树中，所有的vm_area_struct虚存块均由左指针指向相邻的低虚存块，右指针指向相邻的高虚存块。结构定义在include/linux/sched.h中。
操作系统实验报告--实验一--进程管理
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
山东大学操作系统实验报告4进程同步实验
山东大学操作系统实验报告4进程同步实验
计算机科学与技术学院实验报告 实验题目：实验四、进程同步实验学号： 日期：20120409 班级：计基地12 姓名： 实验目的： 加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥 操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解 Linux 系统中 IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。 实验内容： 抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的 IPC 同步机制编程，实现该问题要求的功能。 硬件环境： 处理器：Intel? Core?i3-2350M CPU @ 2.30GHz ×4 图形：Intel? Sandybridge Mobile x86/MMX/SSE2 内存：4G 操作系统：32位 磁盘：20.1 GB 软件环境： ubuntu13.04 实验步骤： （1）新建定义了producer和consumer共用的IPC函数原型和变量的ipc.h文件。
（2）新建ipc.c文件，编写producer和consumer 共用的IPC的具体相应函数。 （3）新建Producer文件，首先定义producer 的一些行为，利用系统调用，建立共享内存区域，设定其长度并获取共享内存的首地址。然后设定生产者互斥与同步的信号灯，并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时，相应的信号灯就会阻止他，当共享内存区域已满时，信号等也会提示生产者不能再往共享内存中放入内容。 （4）新建Consumer文件，定义consumer的一些行为，利用系统调用来创建共享内存区域，并设定他的长度并获取共享内存的首地址。然后设定消费者互斥与同步的信号灯，并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时，相应的信号灯就会阻止它，当共享内存区域已空时，信号等也会提示生产者不能再从共享内存中取出相应的内容。 运行的消费者应该与相应的生产者对应起来，只有这样运行结果才会正确。
操作系统实验报告
操作系统实验报告 ' 学号： 姓名： 指导老师： 完成日期： ~
目录 实验一 (1) 实验二 (2) 实验三 (7) 实验四 (10) 实验五 (15) 实验六 (18) 实验七 (22) \
实验一 UNIX/LINUX入门 一、实验目的 了解 UNIX/LINUX 运行环境，熟悉UNIX/LINUX 的常用基本命令，熟悉和掌握UNIX/LINUX 下c 语言程序的编写、编译、调试和运行方法。 二、实验内容 熟悉 UNIX/LINUX 的常用基本命令如ls、who、pwd、ps 等。 练习 UNIX/LINUX的文本行编辑器vi 的使用方法 熟悉 UNIX/LINUX 下c 语言编译器cc/gcc 的使用方法。用vi 编写一个简单的显示“Hello,World!”c 语言程序，用gcc 编译并观察编译后的结果，然后运行它。 三、实验要求 按照要求编写程序，放在相应的目录中，编译成功后执行，并按照要求分析执行结果，并写出实验报告。 四、实验程序 #include <> #include <> int main() { printf ("Hello World!\n"); return 0; } 五、实验感想 通过第一次室验，我了解 UNIX/LINUX 运行环境，熟悉了UNIX/LINUX 的常用基本命令，熟悉和掌握了UNIX/LINUX 下c 语言程序的编写、编译、调试和运行方法。
实验二进程管理 一、实验目的 加深对进程概念的理解，明确进程与程序的区别；进一步认识并发执行的实质。 二、实验内容 （1）进程创建 编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示“a“；子进程分别显示字符”b“和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程控制 修改已编写的程序，将每一个进程输出一个字符改为每一个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 （3）进程的管道通信 编写程序实现进程的管道通信。使用系统调用pipe()建立一个管道，二个子进程P1 和P2 分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 父进程从管道中读出二个来自子进程的信息并显示（要求先接收P1，再接收P2）。 三、实验要求 按照要求编写程序，放在相应的目录中，编译成功后执行，并按照要求分析执行结果，并写出实验报告。 四、实验设计 1、功能设计 （1）进程创建 使用fork（）创建两个子进程，父进程等待两个子进程执行完再运行。 （2）进程控制 使用fork（）创建两个子进程，父进程等待两个子进程分别输出一句话再运行。 （3）进程的管道通信 先创建子进程1，向管道写入一句话，子进程1结束后创建子进程2，向管道写入一句话，最后父进程从管道中读出。 2、数据结构 子进程和管道。 3、程序框图
嵌入式操作系统实验报告
中南大学信息科学与工程学院实验报告 姓名：安磊 班级：计科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个部分。如下图：
实时操作系统报告
实时操作系统课程实验报告 专业：通信1001 学号：3100601025 姓名：陈治州 完成时间：2013年6月11日
实验简易电饭煲的模拟 一．实验目的： 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，基于多任务的模式的编程方法。锻炼综合应用多任务机制，任务间的通信机制，内存管理等的能力。 二．实验要求： 1.按“S”开机，系统进入待机状态，时间区域显示当前北京时间，默认模式“煮饭”; 2.按“C”选择模式，即在“煮饭”、“煮粥”和“煮面”模式中循环选择； 3.按“B”开始执行模式命令，“开始”状态选中，时间区域开始倒计时，倒计时完成后进入“保温”状态，同时该状态显示选中，时间区域显示保温时间； 4.按“Q”取消当前工作状态，系统进入待机状态，时间区域显示北京时间，模式为当前模式； 5.按“X”退出系统，时间区域不显示。 6.煮饭时长为30，煮粥时长为50，煮面时长为40. 三．实验设计： 1.设计思路： 以老师所给的五个程序为基础，看懂每个实验之后，对borlandc的操作有了大概的认识，重点以第五个实验Task_EX为框架，利用其中界面显示与按键扫描以及做出相应的响应，对应实现此次实验所需要的功能。 本次实验分为界面显示、按键查询与响应、切换功能、时钟显示与倒计时模块，综合在一起实验所需功能。 2.模块划分图： （1）界面显示： Main（） Taskstart（） Taskstartdispinit（） 在TaskStartDispInit()函数中，使用PC_DispStr()函数画出界面。
（2）按键查询与响应： Main（） Taskstart（） 在TaskStart()函数中，用if (PC_GetKey(&key) == TRUE)判断是否有按键输入。然后根据key 的值，判断输入的按键是哪一个；在响应中用switch语句来执行对应按键的响应。 （3）切换功能： l计数“C”按 键的次数 M=l%3 Switch(m) M=0，1，2对应于煮饭，煮粥，煮面，然后使用PC_DispStr()函数在选择的选项前画上“@”指示，同时，在其余两项钱画上“”以“擦出”之前画下的“@”，注意l自增。 四.主要代码： #include "stdio.h" #include "includes.h" #include "time.h" #include "dos.h" #include "sys/types.h" #include "stdlib.h" #define TASK_STK_SIZE 512 #define N_TASKS 2 OS_STK TaskStk[N_TASKS][TASK_STK_SIZE]; OS_STK TaskStartStk[TASK_STK_SIZE]; INT8U TaskData[N_TASKS];
操作系统实验报告4
《操作系统》实验报告 实验序号： 4 实验项目名称：进程控制
Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜ 修改后: #include
实验任务:写出程序的运行结果。 4．正在运行的进程 （2）、编程二下面给出了一个使用进程和操作系统版本信息应用程序(文件名为4-5.cpp)。它利用进程信息查询的API函数GetProcessVersion()与GetVersionEx()的共同作用。确定运行进程的操作系统版本号。阅读该程序并完成实验任务。 #include
操作系统实验报告
操作系统实验报告 集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289-
实验二进程调度1．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 2．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。 程序要求如下： 1）输出系统中进程的调度次序； 2）计算CPU利用率。 3．实验环境 Windows操作系统、VC++6.0 C语言 4设计思想： （1）程序中进程可用PCB表示，其类型描述如下：
structPCB_type { intpid;//进程名 intstate;//进程状态 2——表示“执行”状态 1——表示“就绪”状态 0——表示“阻塞”状态 intcpu_time;//运行需要的CPU时间（需运行的时间片个数） } 用PCB来模拟进程； （2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。队列类型描述如下： structQueueNode{ structPCB_typePCB; StructQueueNode*next; } 并设全程量： structQueueNode*ready_head=NULL,//ready队列队首指针 *ready_tail=NULL,//ready队列队尾指 针
操作系统实验报告心得体会
操作系统实验报告心得体会 每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美,但是我总是很投入的去研究去学习。所以在这两周的课设中,熬了2个通宵,生物钟也严重错乱了。但是每完成一个任务我都兴奋不已。一开始任务是任务,到后面任务就成了自己的作品了。总体而言我的课设算是达到了老师的基本要求。总结一下有以下体会。 1、网络真的很强大,用在学习上将是一个非常高效的助手。几乎所有的资料都能够在网上找到。从linux虚拟机的安装,到linux的各种基本命令操作,再到gtk的图形函数,最后到文件系统的详细解析。这些都能在网上找到。也因为这样,整个课程设计下来,我浏览的相关网页已经超过了100个(不完全统计)。当然网上的东西很乱很杂,自己要能够学会筛选。 不能决定对或错的,有个很简单的方法就是去尝试。就拿第二个实验来说,编译内核有很多项小操作,这些小操作错了一项就可能会导致编译的失败,而这又是非常要花时间的,我用的虚拟机,编译一次接近3小时。所以要非常的谨慎,尽量少出差错,节省时间。多找个几个参照资料,相互比较,
慢慢研究,最后才能事半功倍。 2、同学间的讨论,这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。能和学长学姐讨论当然再好不过了,没有这个机会的话,和自己班上同学讨论也是能够受益匪浅的。大家都在研究同样的问题,讨论起来,更能够把思路理清楚,相互帮助,可以大大提高效率。 3、敢于攻坚,越是难的问题,越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的,毕竟有了精力才能够打持久战。但是做课设一定要有状态,能够在吃饭,睡觉,上厕所都想着要解决的问题,这样你不成功都难。 4、最好在做课设的过程中能够有记录的习惯,这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到的段错误的问题,让我都不知道从何下手。在经过大量的资料查阅之后,我对段错误有了一定的了解,并且能够用相应的办法来解决。 在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的 1)访问系统数据区,尤其是往系统保护的内存地址写数据,最常见就是给一个指针以0地址 2)内存越界(数组越界,变量类型不一致等) 访问到不属于你的内存区域
操作系统实验报告
操作系统教程 实 验 指 导 书 姓名： 学号： 班级：软124班 指导老师：郭玉华 2014年12月10日
实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序： E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： 有可能是因为DOS下路径的问题 （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 因为程序是个死循环程序 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环： 屏蔽j循环： _______________________________________________________________________________调整循环变量i的循环次数：
操作系统实验报告
操作系统实验报告 实验名称: 系统的引导 所在班级: 指导老师: 老师 实验日期: 2014年3 月29 日
一、实验目的 ◆熟悉hit-oslab实验环境； ◆建立对操作系统引导过程的深入认识； ◆掌握操作系统的基本开发过程； ◆能对操作系统代码进行简单的控制，揭开操作系统的神秘面纱。 二、实验容 1. 阅读《Linux核完全注释》的第6章引导启动程序，对计算机和Linux 0.11的引导过程进行初步的了解。 2. 按照下面的要求改写0.11的引导程序bootsect.s。 3. 有兴趣同学可以做做进入保护模式前的设置程序setup.s。 4. 修改build.c，以便可以使用make BootImage命令 5. 改写bootsect.s主要完成如下功能： bootsect.s能在屏幕上打印一段提示信息XXX is booting...，其中XXX是你给自己的操作系统起的名字，例如LZJos、Sunix等。 6. 改写setup.s主要完成如下功能： bootsect.s能完成setup.s的载入，并跳转到setup.s开始地址执行。而setup.s 向屏幕输出一行"Now we are in SETUP"。setup.s能获取至少一个基本的硬件参数（如存参数、显卡参数、硬盘参数等），将其存放在存的特定地址，并输出到屏幕上。setup.s不再加载Linux核，保持上述信息显示在屏幕上即可。 三、实验环境
本实验使用的系统是windows系统或者是Linux系统，需要的材料是osexp。 四、实验步骤 1. 修改bootsect.s中的提示信息及相关代码; 到osexp\Linux-0.11\boot目录下会看到图1所示的三个文件夹，使用UtraEdit 打开该文件。将文档中的98行的mov cx,#24修改为mov cx,#80。同时修改文档中的第246行为图2所示的情形。 图1图2 图3 2. 在目录linux-0.11\boot下,分别用命令as86 -0 -a -o bootsect.obootsect.s和 ld86 -0 -s -obootsectbootsect.o编译和bootsect.s，生成bootsect文件; 在\osexp目录下点击MinGW32.bat依此输入下面的命令： cd linux-0.11 cd boot as86 -0 -a -o bootsect.obootsect.s ld86 -0 -s -o bootsectbootsect.o
嵌入式实时操作系统实验报告
嵌入式实时操作系统实验报告 任务间通信机制的建立 系别计算机与电子系 专业班级***** 学生姓名****** 指导教师 ****** 提交日期 2012 年 4 月 1 日
一、实验目的 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，任务使用信号量的一般原理。掌握在基于优先级的可抢占嵌入式实时操作系统的应用中，出现优先级反转现象的原理及解决优先级反转的策略——优先级继承的原理。 二、实验内容 1.建立并熟悉Borland C 编译及调试环境。 2.使用课本配套光盘中第五章的例程运行（例5-4,例5-5，例5-6），观察运行结果，掌握信号量的基本原理及使用方法，理解出现优先级反转现象的根本原因并提出解决方案。 3.试编写一个应用程序，采用计数器型信号量（初值为2），有3个用户任务需要此信号量，它们轮流使用此信号量，在同一时刻只有两个任务能使用信号量，当其中一个任务获得信号量时向屏幕打印“TASK N get the signal”。观察程序运行结果并记录。 4. 试编写一个应用程序实现例5-7的内容，即用优先级继承的方法解决优先级反转的问题，观察程序运行结果并记录。 5.在例5-8基础上修改程序增加一个任务HerTask,它和YouTask一样从邮箱Str_Box里取消息并打印出来，打印信息中增加任务标识，即由哪个任务打印的；MyTask发送消息改为当Times为5的倍数时才发送，HerTask接收消息采用无等待方式，如果邮箱为空，则输出“The mailbox is empty”, 观察程序运行结果并记录。 三、实验原理 1. 信号量 μC/OS-II中的信号量由两部分组成：一个是信号量的计数值，它是一个16位的无符号整数（0 到65,535之间）；另一个是由等待该信号量的任务组成的等待任务表。用户要在OS_CFG.H中将OS_SEM_EN开关量常数置成1，这样μC/OS-II 才能支持信号量。
《 Windows7 操作系统》实验报告
实验（一） Windows 7基本操作 一、实验目的 1．掌握文件和文件夹基本操作。 2．掌握“资源管理器”和“计算机”基本操作。 二、实验要求 1.请将操作结果用Alt+Print Screen组合键截图粘贴在题目之后。 2．实验完成后，请将实验报告保存并提交。 三、实验内容 1．文件或文件夹的管理（提示：此题自行操作一遍即可，无需抓图）★期末机试必考题★ (1) 在D：盘根目录上创建一个名为“上机实验”的文件夹，在“上机实验”文件夹中创建1个名为“操作系统上机实验”的空白文件夹和2个分别名为“2.xlsx”和“3.pptx”的空白文件，在“操作系统上机实验”文件夹中创建一个名为“1.docx”的空白文件。 (2) 将“1.docx”改名为“介绍信.docx”；将“上机实验”改名为“作业”。 (3) 在“作业”文件夹中分别尝试选择一个文件、同时选择两个文件、一次同时选择所有文件和文件夹。 (4) 将“介绍信.docx”复制到C：盘根目录。 (5) 将D：盘根目录中的“作业”文件夹移动到C：盘根目录。 (6) 将“作业”文件夹中的“2.xlsx”文件删除放入“回收站”。 (7) 还原被删除的“2.xlsx”文件到原位置。 2．搜索文件或文件夹，要求如下： 查找C盘上所有以大写字母“A”开头，文件大小在10KB以上的文本文件。（提示：搜索时，可以使用“?”和“*”。“？”表示任意一个字符，“*”表示任意多个字符。）
3. 在桌面上为C：盘根目录下的“作业”文件夹创建一个桌面快捷方式。★期末机试必考题★ 3．“计算机”或“资源管理器”的使用 (1) 在“资源管理器”窗口，设置以详细信息方式显示C:\WINDOWS中所有文件和文件夹，使所有图标按类型排列显示，并不显示文件扩展名。（提示：三步操作全部做完后，将窗口中显示的最终设置结果抓一张图片即可） (2) 将C：盘根目录中“介绍信.docx”的文件属性设置为“只读”和“隐藏”，并设置在窗口中显示“隐藏属性”的文件或文件夹。（提示：请将“文件夹”对话框中选项设置效果与C：盘根目录中该文件图标呈现的半透明显示效果截取在一整张桌面图片中即可） 4．回收站的设置 设置删除文件后，不将其移入回收站中，而是直接彻底删除功能。
操作系统实验报告
《操作系统原理》实验报告 实验项目名称:模拟使用银行家算法判断系统的状态 一、实验目的 银行家算法是操作系统中避免死锁的算法，本实验通过对银行家算法的模拟，加强对操作系统中死锁的认识，以及如何寻找到一个安全序列解除死锁。 二、实验环境 1、硬件：笔记本。 2、软件：Windows 7 , Eclipse。 三、实验内容 1.把输入资源初始化，形成资源分配表； 2.设计银行家算法，输入一个进程的资源请求，按银行家算法步骤进行检查； 3.设计安全性算法，检查某时刻系统是否安全； 4.设计显示函数，显示资源分配表，安全分配序列。 四、数据处理与实验结果 1.资源分配表由进程数组，Max，Allocation，Need，Available 5个数组组成； 实验采用数据为下表： 2.系统总体结构，即菜单选项，如下图
实验的流程图。如下图 3.实验过程及结果如下图所示
1.首先输入进程数和资源类型及各进程的最大需求量 2.输入各进程的占有量及目前系统的可用资源数量 3.初始化后，系统资源的需求和分配表 4.判断线程是否安全
5.对线程进行死锁判断 五、实验过程分析 在实验过程中，遇到了不少问题，比如算法无法回滚操作，程序一旦执行，必须直接运行到单个任务结束为止，即使产生了错误，也必须等到该项任务结束才可以去选择别的操作。但总之，实验还是完满的完成了。 六、实验总结 通过实验使我对以前所学过的基础知识加以巩固，也对操作系统中抽象理论知识加以理解，例如使用Java语言来实现银行家算法，在这个过程中更进一步了解了银行家算法，通过清晰字符界面能进行操作。不过不足之处就是界面略显简洁，对于一个没有操作过计算机的人来说，用起来可能还是有些难懂。所以，以后会对界面以及功能进行完善，做到人人都可以看懂的算法。
操作系统实验报告
操作系统实验报告 Document number：NOCG-YUNOO-BUYTT-UU986-1986UT
许昌学院 《操作系统》实验报告书学号： 姓名：闫金科 班级：14物联网工程 成绩: 2016年02月
实验一Linux的安装与配置 一、实验目的 1.熟悉Linux系统的基本概念，比如Linux发行版、宏内核、微内核等。 2.掌握Linux系统的安装和配置过程，初步掌握Linux系统的启动和退出方 法。 3.熟悉Linux系统的文件系统结构，了解Linux常用文件夹的作用。 二、实验内容 1.从网络上下载VMware软件和两个不同Linux发行版镜像文件。 2.安装VMware虚拟机软件。 3.在VMware中利用第一个镜像文件完成第一个Linux的安装，期间完成网络 信息、用户信息、文件系统和硬盘分区等配置。 4.在VMware中利用第二个镜像文件完成第二个Linux的安装，并通过LILO或 者GRUB解决两个操作系统选择启动的问题。 5.启动Linux系统，打开文件浏览器查看Linux系统的文件结构，并列举出 Linux常用目录的作用。 三、实验过程及结果 1、启动VMware，点击新建Linux虚拟机，如图所示： 2、点击下一步，选择经典型，点击下一步在选择客户机页面选择 Linux，版本选择RedHatEnterpriseLinux5，如图所示： 3、点击下一步创建虚拟机名称以及所要安装的位置，如图所示： 4、点击下一步，磁盘容量填一个合适大小，此处选择默认值大小 10GB，如图所示： 5、点击完成，点击编辑虚拟机设置，选择硬件选项中的CD-ROM （IDE...）选项，在右侧连接中选择“使用ISO镜像（I）”选项，点 击“浏览”，找到Linux的镜像文件，如图所示：
操作系统实验报告
实验报告 实验课程名称：操作系统 实验地点：南主楼七楼机房 2018—2019学年（一）学期 2018年 9月至 2019 年 1 月 专业： 班级： 学号： 姓名： 指导老师：刘一男
实验一 实验项目：分时系统模拟 实验学时：2实验日期： 2018-10-25 成绩： 实验目的利用程序设计语言模拟分时系统中多个进程按时间片轮转调度算法进行进程调度的过程； 假设有五个进程A，B，C，D，E，它们的到达时间及要求服务的时间分别为：进程名 A B C D E 到达时间0 1 2 3 4 服务时间 4 3 4 2 4 时间片大小为1，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：BDACE
（1）修改时间片大小为2，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：ADBCE （2）修改时间片大小为4，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间.
顺序：ABCDE 1、思考 时间片的大小对调度算法产生什么影响？对计算机的性能产生什么影响？答：通过对时间片轮转调度算法中进程最后一次执行时间片分配的优化,提出了一种改进的时间片轮转调度算法,该算法具有更好的实时性,同时减少了任务调度次数和进程切换次数,降低了系统开销,提升了CPU的运行效率,使操作系统的性能得到了一定的提高。 A B C D E 时间片为1 周转时间12 9 14 8 13 3 3 3.5 4 3.25 带权周转 时间 时间片为2 周转时间8 12 13 7 13 2 4 3.25 3.5 3.25 带权周转 时间 时间片为4 周转时间 4 6 9 10 13 1 2 2.25 5 3.25 带权周转 时间
操作系统实验报告
操作系统教程实验报告 专业班级 学号 姓名 指导教师
实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环：
操作系统实验报告
操作系统实验报告 银行家算法 班级：计算机()班 姓名：李君益 学号：(号) 提交日期： 指导老师: 林穗 一、设计题目 加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。 二、设计要求
内容： 编制银行家算法通用程序，并检测思考题中所给状态的安全性。 要求： (1)下列状态是否安全？(三个进程共享个同类资源) 进程已分配资源数最大需求数 (状态) (状态) (2)考虑下列系统状态 分配矩阵最大需求矩阵可用资源矩阵 问系统是否安全？若安全就给出所有的安全序列。若进程请求()，可否立即分配？ 三、设计分析 一．关于操作系统的死锁 ．死锁的产生 计算机系统中有许多独占资源，他们在任一时刻只能被一个进程使用，如磁带机，绘图仪等独占型外围设备，或进程表，临界区等软件资源。两个进程同时向一台打印机输出将导致一片混乱，两个进程同时进入临界区将导致数据库错误乃至程序崩溃。正因为这些原因，所有操作系统都具有授权一个进程独立访问某一辞源的能力。一个进程需要使用独占型资源必须通过以下的次序： ●申请资源 ●使用资源 ●归还资源 若申请施资源不可用，则申请进程进入等待状态。对于不同的独占资源，进程等待的方式是有差别的，如申请打印机资源、临界区资源时，申请失败将一位这阻塞申请进程；而申请打开文件文件资源时，申请失败将返回一个错误码，由申请进程等待一段时间之后重试。只得指出的是，不同的操作系统对于同一种资源采取的等待方式也是有差异的。 在许多应用中，一个进程需要独占访问多个资源，而操作系统允许多个进程并发执行共享系统资源时，此时可能会出现进程永远被阻塞的现象。这种现象称为“死锁”。 2.死锁的定义 一组进程处于死锁状态是指：如果在一个进程集合中的每个进程都在等待只能由该集合中的其他一个进程才能引发的时间，则称一组进程或系统此时发生了死锁。 ．死锁的防止 .死锁产生的条件： ●互斥条件
实时操作系统实验报告2
实时操作系统实验报告 专业：11通信工程 学号：20110306136 姓名: 王帅 指导老师：申屠浩
实验二 任务管理实验 实验目的： 1、理解任务管理的基本原理，了解任务的各个基本状态及其变迁过程； 2、掌握μC/OS -II 中任务管理的基本方法（挂起、解挂）； 3、熟练使用μC/OS -II 任务管理的基本系统调用。 实验要求与思路： 为了体现任务的各个基本状态及其变迁过程，本实验设计了T0、T1和T3三个任务，它们交替运行，如图2-2所示。 T0 T1 T2 T3 T4 T5 T6 T7 T8 图2-2 注意： 图中的栅格并不代表严格的时间刻度，而仅仅表现各任务启动和执行的相对先后关系。 说明： 在系统完成初始化后，可以先创建并启动优先级最低的TaskStart ，由它创建其他3个应用任务T0、T1和T2，之后整个系 T0 T2 T1 T0 T1 T2 T1 T0
统的运行流程如下： 1）优先级最高的T0开始执行，之后T0挂起自己； 2）然后系统调度选中T1开始执行，之后T1挂起自己； 3）接着系统调度选中T2,之后唤醒T0； 4）如此循环 实现提示： 在启动任务中创建三个任务后，应挂起任务1和任务2。 在每个任务恢复其它任务并挂起自己之前，显示当前三个任务的状态，并延时1秒。 函数说明： void PC_GetDateTime (char *s)； 获取"YYYY-MM-DD HH:MM:SS"格式的时间字串存放在字符串s中，s的长度最少为21字节。 void PC_DispStr (INT8U x, INT8U y, INT8U *s, INT8U color)； 在y行x列以color颜色值显示字串s，注意color由背景色和前景色两种颜色构成。 INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)； 按时、分、秒、毫秒设置进行延时。 void OSTimeDly (INT16U ticks) 按ticks值进行延时，1 ticks一般为10ms。 INT32U OSTimeGet (void)