实验一 进程状态转换
实验一进程的状态及其转换
一、实验目的:
自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。
二、实验内容及要求：
1)设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。
2)独立编写、调试程序。进程的数目、进程的状态模型（三状态、五状态、七状
态或其它）以及PCB的组织形式可自行选择。
3)合理设计与进程PCB相对应的数据结构。PCB的内容要涵盖进程的基本信息、控
制信息、资源需求及现场信息。
4)设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、
组织结构的变化。
三、程序流程图：
四、使用的数据结构及说明：
在本实验中，主要用到的数据结构是PCB的结构，其中PCB的数据结构如下：
struct PCB
{
int P_Id; //PCB的ID号
char P_Name[10]; //PCB的名称
char P_State[10]; //PCB状态
int P_Runtime; //PCB的所需要的运行时间
int P_Requiry; //PCB所需要的资源要求
struct PCB * next ; //PCB块的下一个指针
} ;
其中，P_Id,和P_Name用来标示一个进程，而P_State用来标示进程的五种状态：Create_state,Ready_state,Block_state,Run_state,Exit_state。P_Runtime标示要完成一个进程所需要的时间。P_Requiry标示一个进程的执行所需要的其他条件，当其他的条件满足，则P_Requiry置1，否则置0。Struct PCB * next 用来指向同一队列中的下一个PCB 块。
五、参考程序源代码:
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include
/*全局结构体及变量定义*/
struct PCB
{
int P_Id; //PCB的ID号
char P_Name[10]; //PCB的名称
char P_State[10]; //PCB状态
int P_Runtime; //PCB的所需要的运行时间
int P_Requiry; //PCB所需要的资源要求
struct PCB * next ; //PCB块的下一个指针
} ;
struct PCB * Create_state; //创建状态
struct PCB * Run_state; //运行状态
struct PCB * Ready_state; //就绪状态
struct PCB * Block_state; //阻塞状态
struct PCB * Exit_state; //退出状态
int signal4=0; //标示进程4的完成状态
int signal5=0; //标示进程5的完成状态
void InsertQueue(struct PCB **head,struct PCB *node) //将进程插入到队列的尾部
{
struct PCB * p,*q;
node->next=NULL;
if(*head==NULL) //如果队列为空
{
*head=node;
}
else //队列不空
{
p=*head;
q=p->next;
while(q!=NULL) //找到最后的元素位置
{
p=q;
q=q->next;
}
p->next=node; //将节点插入队列
}
}
void DeleteQueue(struct PCB **head,struct PCB *node)//撤销进程，从队列中删除元素{
struct PCB *p,*q;
p=node;
q=*head;
if(*head==NULL||node==NULL) //如果队列为空，返回
return ;
if(*head==node) //如果要删除的元素是队首元素
{
*head=(*head)->next;
return;
}
else //如果不是队列的首元素
{
while(q->next!=p&&q->next!=NULL)
q=q->next;
q=p->next;
p->next=NULL;
}
}
void Display_Process(struct PCB * node) //打印进程状态的元素函数
{
printf("\n\nthis process Id is : %d \n",node->P_Id);
printf("this process name is : %s \n",node->P_Name);
printf("this process state is : on %s \n ",node->P_State);
printf("this process Runtime is : %d \n",node->P_Runtime);
if(node->P_Requiry)
printf("this process resource is ready \n");
else
printf("this process resource is not ready ! \n");
}
void DispatchToBlock(struct PCB *node) //调度到阻塞状态的函数
{
if(!node->P_Requiry) //如果所需要的资源没有满足则，调度到阻塞状态 {
strcpy(node->P_State,"block");
InsertQueue(&Block_state,node); //插入到阻塞队列
Display_Process(node);
}
}
void DispatchToReady(struct PCB *node) //调度到就绪状态的函数
{
if(node->P_Requiry) //如果所需的资源满足，则调度
{
strcpy(node->P_State,"Ready");
InsertQueue(&Ready_state,node);
Display_Process(node);
}
}
void DispatchBlockToReady() //从阻塞状态调度到就绪状态函数
{
struct PCB*p,*q;
q=Block_state;
while(q!=NULL) //如果阻塞状态队列不空
{
p=q;
q=q->next;
if(signal4&&p->P_Id==1) //如果所需要的资源满足
{
p->P_Requiry=1;
DeleteQueue(&Block_state,p);
strcpy(p->P_State,"ready");
InsertQueue(&Ready_state,p);
printf("process1 will be in the state of ready!\n");
Display_Process(p);
}
if(signal5&&p->P_Id==2)
{
p->P_Requiry=1;
DeleteQueue(&Block_state,p);
strcpy(p->P_State,"ready");
InsertQueue(&Ready_state,p);
printf("process2 will be in the state of ready!\n");
Display_Process(p);
}
}
}
void Create_Process() //创建进程函数
{
int i;
struct PCB *p;
char name[10];
strcpy(name,"process");
for(i=1;i<3;i++) //动态创建2个处于阻塞状态的进程
{
p=(struct PCB *)malloc(sizeof(struct PCB));
p->P_Id=i;
name[7]=i+'0';
name[8]='\0';
strcpy(p->P_Name,name);
strcpy(p->P_State,"create");
p->P_Runtime=1; //所需要的时间片为1
p->P_Requiry=0;
Display_Process(p);
Sleep(4000);
printf(" \n process%d will be in the state of Block, waiting the resource ready \n\n",i);
DispatchToBlock(p); //同时调度到阻塞队列
}
for(i=3;i<7;i++) //创建4个就绪状态的队列
{
p=(struct PCB *)malloc(sizeof(struct PCB));
p->P_Id=i;
name[7]=i+'0';
name[8]='\0';
strcpy(p->P_Name,name);
strcpy(p->P_State,"create");
p->P_Requiry=1;
if(i==6) //在这里个进程6所需要的时间片为2 p->P_Runtime=2;
else
p->P_Runtime=1;
Display_Process(p);
Sleep(4000);
printf(" \n process%d will be in the state of Ready, waiting to run \n\n",i); DispatchToReady(p);
}
}
void display(struct PCB **head) //打印各个状态队列里进程数目
{
struct PCB *p;
p=*head;
while(p!=NULL)
{
Sleep(2000);
printf("\n\nthis process Id is : %d \n",p->P_Id);
printf("this process name is : %s \n",p->P_Name);
printf("this process state is : on %s \n ",p->P_State);
printf("this process Runtime is : %d \n",p->P_Runtime);
if(p->P_Requiry)
printf("this process resource is ready \n");
else
printf("this process resource is not ready ! \n");
p=p->next;
}
}
void Process_Run() //进程运行函数
{
struct PCB *p;
while(Ready_state!=NULL) //就绪队列不空则继续执行
{
p=Ready_state;
if(p->P_Runtime<=0) break; //如果时间片执行完了，则跳出循环 strcpy(p->P_State,"running");
Display_Process(p);
p->P_Runtime=p->P_Runtime-1;
Sleep(4000);
if(p->P_Runtime>0) //没有完成，则进入就绪队列
{
printf("this process is not finished,will be dispatch to the ready queue!!\n");
DeleteQueue(&Ready_state,p);
strcpy(p->P_State,"ready");
InsertQueue(&Ready_state,p);
Display_Process(p);
}
else //执行完成，则跳出，并发送相应的信息
{
printf("\n\nProcess%d is finished and will be in the state of exit!\n\n",p->P_Id);
if(p->P_Id==4) signal4=1;
if(p->P_Id==5) signal5=1;
DeleteQueue(&Ready_state,p);
}
if(signal4||signal5)
DispatchBlockToReady(); //如果资源满足，则将进程调度到就绪队列 }
if(Ready_state==NULL)
printf("\nthere is no process ready!\n STOP Machine!!!\n");
}
void main(int argc,char * argv[]) //主函数
{
char c='c'; //界面
printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n"); printf("...................................Ding Hai bo\n");
printf("......Press s to start the process.......\n");
scanf("%c",&c);
while(1)
{
if(c=='s'||c=='S')break;
scanf("%c",&c);
}
Create_Process(); //调用创建进程函数
printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
printf("\n>>>>>>> Display the Ready queue >>>>>>>>>>>>>>>\n");
Sleep(5000);
display(&Ready_state); ////////////////显示就绪队列里的进程
printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
printf("\n>>>>>>>> Display the Block queue >>>>>>>>>>>>\n");
Sleep(5000); //显示阻塞队列函数
display(&Block_state); /////////////////////
printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n\n");
printf("\n>>>>>>>> Now the process start to run >>>>>>>>>>>\n"); Sleep(5000);
Process_Run(); //调用进程运行函数
}
六．程序使用说明：
1）输入字符‘s’启动程序
2）程序将自动执行，自动创建进程，运行进程和结束进程。
3）程序将自动显示每一步进程的执行状态。
七．实验结果分析
1）写出各个进程被创建后的初始状态，并列出各进程初始时的PCB内容。
2）阐述系统中各进程并发执行的过程，并分析就绪队列和等待队列的变化过程。3）描述Create_Process()函数和 Process_Run()函数的执行流程。
词法分析程序设计与实现
` 实验一词法分析程序设计与实现 一、实验目的及容 调试并完成一个词法分析程序，加深对词法分析原理的理解。 二、实验原理（状态转换图） 1、C语言子集 （1）关键字： begin if then while do end 所有关键字都是小写。 （2）运算符和界符： := + – * / < <= <> > >= = ; ( ) # （3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义：ID=letter（letter| digit）* NUM=digit digit * （4）空格由空白、制表符和换行符组成。空格一般用来分隔ID、NUM,运算符、界符和关键字，词法分析阶段通常被忽略。 2、各种单词符号对应的种别码 文档Word
` 3、词法分析程序的功能 输入：所给文法的源程序字符串。 输出：二元组（syn，token或sum）构成的序列。其中：syn为单词种别码； token为存放的单词自身字符串； sum为整型常数。 二、软件平台及工具 PC机以及VISUAL C++6.0软件。 三、实验方法、步骤（或：程序代码或操作过程）（1）程序代码： #include
linux进程控制 实验报告
长安大学 操作系统实验报告 实验课程：操作系统 实验名称：linux进程控制 学院：信息学院 专业：软件工程 学号：2406090106 姓名：刘建 日期：2012-5-09
一、实验目的 熟悉进程的创建过程，了解系统调用函数fork() 和execl()。 二、实验内容 1、阅读实例代码fork1，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握系统调用fork( )的用法，返回值的意义。 2、阅读实例代码fork2，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握在程序中运行一个操作系统命令和运行一个程序的方法。 3、修改fork2，使之能把运行的命令和程序作为参数传给fork2。 三、设计思想 1、程序框架
pid = -1 pid = 0pid> 0 2、用到的文件系统调用函数 fork() 和execl() 四、调试过程 1、测试数据设计 （1）fork1 命名程序1： 编写程序1：
编译程序1： 运行程序1： (2)fork2
编写程序2： 运行程序2：
(3)修改fork2 编写修改程序2： 修改后的运行结果： 2、测试结果分析 （1）对于程序1：因为系统调用fork()函数是一次调用两次返回值，而且先生成子进程还是父进程是不确定的，所以第一次执行生成子进程的时候返回的pid = 0，判断pid!=-1，所以输出了I’m the child. I’m the parent. 第二次，执行父进程的时候，返回的是子进程的进程号pid> 0，即pid的值仍然不为-1，所以又输出了一次I’m the child. I’m the parent。 （2）对于程序2：第一次调用fork()函数时，由于执行的是子进程还是父进程是随机的，所以第一次对父进程返回的是子进程的进程号（大于0），即pid> 0，所以输出I’m the parent. Program end.当第二次执行子进程时返回值是0，即pid = 0，所以输出I’m the child. 并调用了execl()函数，查看了指定路径中的文件。
实验2 进程状态转换及其PCB的变化
实验2进程状态转换及其PCB的变化 1.目的 自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。 2. 内容及要求 1）设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。 2）独立编写、调试程序。进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。 3）合理设计与进程PCB相对应的数据结构。PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。 4）设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB 内容、组织结构的变化。 5）代码书写要规范，要适当地加入注释。 6）鼓励在实验中加入新的观点或想法，并加以实现。 7）认真进行预习，完成预习报告。 8）实验完成后，要认真总结，完成实验报告。 3.程序流程图 进程的三种基本状态及其转换如下图所示。
开始 输入要执行的指令 1？N 2？N 3？N 4？ N 5？N 0？Y Y 结束 N 提示输入错误 就绪队列已 满？ N 创建进程 Y 提示就绪队列 已满Y 有进程处于运行状态? Y 该进程执行一个时间片 后放回就绪队列 N 将就绪队列中优先级最高的进程放入运行队列 有进程处于运行状态? Y 该进程所需执行时间减1，并回到就绪队列 Cputime++ Y 有进程处于运行状态？ Y 将该进程放入阻塞 队列 N 提示无运行的进程 输入事件发生的进程名称 阻塞队列中有该 进程？ Y 将该进程放入就绪队列 N 提示该进程并 未阻塞 4.数据结构及说明 在本实验中，主要的数据结构是PCB 的数据结构，具体如下： struct process{
操作系统实验-进程控制
实验一、进程控制实验 1.1 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法，了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 1.2 实验说明 1）与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include
Exec 执行成功后将用一个新的程序代替原进程，但进程号不变，它绝不会再返回到调用进程了。如果exec 调用失败，它会返回-1。 wait() 系统调用语法: #include
操作系统精髓与设计原理-第3章 进程描述和控制
第3章进程描述和控制 复习题： 3.1什么是指令跟踪？ 答：指令跟踪是指为该进程而执行的指令序列。 3.2通常那些事件会导致创建一个进程？ 答：新的批处理作业；交互登录；操作系统因为提供一项服务而创建；由现有的进程派生。（详情请参考表3.1） 3.3对于图3.6中的进程模型，请简单定义每个状态。 答：运行态：该进程正在执行。就绪态：进程做好了准备，只要有机会就开始执行。 阻塞态：进程在某些事件发生前不能执行，如I/O操作完成。新建态：刚刚创建的进程，操作系统还没有把它加入到可执行进程组中。退出态：操作系统从可执行进程组中释放出的进程，或者是因为它自身停止了，或者是因为某种原因被取消。 3.4抢占一个进程是什么意思？ 答：处理器为了执行另外的进程而终止当前正在执行的进程，这就叫进程抢占。 3.5什么是交换，其目的是什么？ 答：交换是指把主存中某个进程的一部分或者全部内容转移到磁盘。当主存中没有处于就绪态的进程时，操作系统就把一个阻塞的进程换出到磁盘中的挂起队列，从而使另一个进程可以进入主存执行。 3.6为什么图3.9（b）中有两个阻塞态？ 答：有两个独立的概念：进程是否在等待一个事件（阻塞与否）以及进程是否已经被换出主存（挂起与否）。为适应这种2*2的组合，需要两个阻塞态和两个挂起态。3.7列出挂起态进程的4个特点。 答：1.进程不能立即执行。2.进程可能是或不是正在等待一个事件。如果是，阻塞条件不依赖于挂起条件，阻塞事件的发生不会使进程立即被执行。3.为了阻止进程执行，可以通过代理把这个进程置于挂起态，代理可以是进程自己，也可以是父进程或操作系统。4.除非代理显式地命令系统进行状态转换，否则进程无法从这个状态中转移。 3.8对于哪类实体，操作系统为了管理它而维护其信息表？ 答：内存、I/O、文件和进程。 3.9列出进程控制块中的三类信息。 答：进程标识，处理器状态信息，进程控制信息。 3.10为什么需要两种模式（用户模式和内核模式）？ 答：用户模式下可以执行的指令和访问的内存区域都受到限制。这是为了防止操作系统受到破坏或者修改。而在内核模式下则没有这些限制，从而使它能够完成其功能。 3.11操作系统创建一个新进程所执行的步骤是什么？ 答：1.给新进程分配一个唯一的进程标识号。2.给进程分配空间。3.初始化进程控制块。 4.设置正确的连接。 5.创建或扩充其他的数据结构。 3.12中断和陷阱有什么区别？ 答：中断与当前正在运行的进程无关的某些类型的外部事件相关，如完成一次I/O操作。陷阱与当前正在运行的进程所产生的错误或异常条件相关，如非法的文件访问。 3.13举出中断的三个例子。 答：时钟终端，I/O终端，内存失效。 3.14模式切换和进程切换有什么区别？ 答：发生模式切换可以不改变当前正处于运行态的进程的状态。发生进程切换时，一个正在执行的进程被中断，操作系统指定另一个进程为运行态。进程切换需要保存更
实验1-3 《编译原理》词法分析程序设计方案
实验1-3 《编译原理》S语言词法分析程序设计方案 一、实验目的 了解词法分析程序的两种设计方法之一：根据状态转换图直接编程的方式； 二、实验内容 1．根据状态转换图直接编程 编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。在此，词法分析程序作为单独的一遍，如下图所示。 具体任务有： （1）组织源程序的输入 （2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件 （3）删除注释、空格和无用符号 （4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。将错误信息输出到屏幕上。 （5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。 标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址 注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。 常量表结构：常量名，常量值 三、实验要求 1．能对任何S语言源程序进行分析 在运行词法分析程序时，应该用问答形式输入要被分析的S源语言程序的文件名，然后对该程序完成词法分析任务。 2．能检查并处理某些词法分析错误 词法分析程序能给出的错误信息包括：总的出错个数，每个错误所在的行号，错误的编号及错误信息。 本实验要求处理以下两种错误（编号分别为1，2）： 1：非法字符：单词表中不存在的字符处理为非法字符，处理方式是删除该字符，给出错误信息，“某某字符非法”。 2：源程序文件结束而注释未结束。注释格式为：/* …… */ 四、保留字和特殊符号表
进程管理实验报告
实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义：过程是程序运行过程中对数据集的处理，以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序，甚至在同一数据集上运行多个程序，是一个不同的过程。（2）程序状态：一般来说，一个程序必须有三种基本状态：就绪、执行和阻塞。然而，在许多系统中，过程的状态变化可以更好地描述，并且增加了两种状态：新状态和终端状态。1）就绪状态，当一个进程被分配了除处理器（CPU）以外的所有必要资源时，只要获得了处理器，进程就可以立即执行。此时，进程状态称为就绪状态。在系统中，多个进程可以同时处于就绪状态。通常，这些就绪进程被安排在一个或多个队列中，这些队列称为就绪队列。2）一旦处于就绪状态的进程得到处理器，它就可以运行了。进程的状态称为执行状态。在单处理器系统中，只有一个进程在执行。在多处理器系统中，可能有多个进程在执行中。3）阻塞状态由于某些事件（如请求输入和输出、额外空间等），执行进程被挂起。这称为阻塞状态，也称为等待状态。通常，处于阻塞状态的进程被调度为-？这个队列称为阻塞队列。4）新状态当一个新进程刚刚建立并且还没有放入就绪队列中时，它被称为新状态。5）终止状态是
什么时候-？进程已正常或异常终止，操作系统已将其从系统队列中删除，但尚未取消。这就是所谓的终结状态。（3）过程控制块是过程实体的重要组成部分，是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB，一个不能独立运行的程序可以成为一个可以独立运行的基本单元，并且可以同时执行一个进程。换句话说，在进程的整个生命周期中，操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此，进程控制块是进程存在的唯一标志。当系统创建一个进程时，它需要为它创建一个PCB；当进程结束时，系统回收其PCB，进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识，通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息（process scheduling message）描述性信息是与流程调度相关的一些有关流程状态的信息，包括以下几个方面。流程状态：表
操作系统实验报告+进程状态转换
实验进程状态转换及其PCB的变化 一、程序流程图： 二、使用的数据结构及说明： 在本实验中，主要用到的数据结构是PCB的结构，其中PCB的数据结构如下： struct PCB { int P_Id; //PCB的ID号 char P_Name[10]; //PCB的名称 char P_State[10]; //PCB状态 int P_Runtime; //PCB的所需要的运行时间 int P_Requiry; //PCB所需要的资源要求 struct PCB * next ; //PCB块的下一个指针 } ; 其中，P_Id,和P_Name用来标示一个进程，而P_State用来标示进程的五种状态：
Create_state,Ready_state,Block_state,Run_state,Exit_state。P_Runtime标示要完成一个进程所需要的时间。P_Requiry标示一个进程的执行所需要的其他条件，当其他的条件满足，则P_Requiry 置1，否则置0。Struct PCB * next 用来指向同一队列中的下一个PCB块。 三、程序源代码: #include"stdlib.h" #include"stdio.h" #include"string.h" /********** globle structure and viable ******/ struct PCB { int P_Id; //PCB的ID号 char P_Name[10]; //PCB的名称 char P_State[10]; //PCB状态 int P_Runtime; //PCB的所需要的运行时间 int P_Requiry; //PCB所需要的资源要求 struct PCB * next ; //PCB块的下一个指针 } ; struct PCB * Create_state; //创建状态 struct PCB * Run_state; //运行状态 struct PCB * Ready_state; //就绪状态 struct PCB * Block_state; //阻塞状态 struct PCB * Exit_state; //退出状态 int signal4=0; //标示进程4的完成状态 int signal5=0; //标示进程5的完成状态 void InsertQueue(struct PCB **head,struct PCB *node) /* insert node function */ { struct PCB * p,*q; node->next=NULL; if(*head==NULL) //如果队列为空 { *head=node; } Else //队列不空 { p=*head; q=p->next; while(q!=NULL) //找到最后的元素位置 { p=q; q=q->next; } p->next=node; //将节点插入队列 }
操作系统实验报告--实验一--进程管理
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 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;
进程管理实验报告
进程的控制 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new
program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 3 ．实验步骤 （1）gedit创建进程1.c （2）使用gcc 1.c -o 1编译并./1运行程序1.c #include
实验一 进程状态转换
实验一进程的状态及其转换 一、实验目的: 自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。 二、实验内容及要求： 1)设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。 2)独立编写、调试程序。进程的数目、进程的状态模型（三状态、五状态、七状 态或其它）以及PCB的组织形式可自行选择。 3)合理设计与进程PCB相对应的数据结构。PCB的内容要涵盖进程的基本信息、控 制信息、资源需求及现场信息。 4)设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、 组织结构的变化。 三、程序流程图：
四、使用的数据结构及说明： 在本实验中，主要用到的数据结构是PCB的结构，其中PCB的数据结构如下： struct PCB { int P_Id; //PCB的ID号 char P_Name[10]; //PCB的名称 char P_State[10]; //PCB状态 int P_Runtime; //PCB的所需要的运行时间 int P_Requiry; //PCB所需要的资源要求 struct PCB * next ; //PCB块的下一个指针 } ; 其中，P_Id,和P_Name用来标示一个进程，而P_State用来标示进程的五种状态：Create_state,Ready_state,Block_state,Run_state,Exit_state。P_Runtime标示要完成一个进程所需要的时间。P_Requiry标示一个进程的执行所需要的其他条件，当其他的条件满足，则P_Requiry置1，否则置0。Struct PCB * next 用来指向同一队列中的下一个PCB 块。 五、参考程序源代码: #include"stdlib.h" #include"stdio.h" #include"string.h" #include
实验一-进程控制实验
实验一进程控制 一、实验目的： 加深对进程概念的理解，明确进程和程序的区别；掌握Linux操作系统的进程创建和终止操作，体会父进程和子进程的关系及进程状态的变化；进一步认识并发执行的实质，编写并发程序。 二、实验平台： 虚拟机：VMWare9以上 操作系统：Ubuntu12.04以上 编辑器：Gedit | Vim 编译器：Gcc 三、实验内容： （1）编写一段程序，使用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示“身份信息”：父进程显示“Parent process! PID=xxx1 PPID=xxx2”；子进程显示“Childx process! PID=xxx PPID=xxx”。多运行几次，观察记录屏幕上的显示结果，并分析原因。 说明： xxx1为进程号，用getpid()函数可获取进程号； xxx2为父进程号，用getppid()函数可获取父进程号； Childx中x为1和2，用来区别两个子进程； wait()函数用来避免父进程在子进程终止之前终止。 程序源码： #include
pid_t pid1,pid2; if((pid1=fork())<0){ printf("创建进程1失败"); }else{ if(pid1==0){ //子进程1执行 printf("Child1 process: "); printf("PID=%d PPID=%d \n",getpid(),getppid()); sleep(2); }else{ if((pid2=fork())<0){ printf("创建进程2失败"); }else{ if(pid2==0){ //子进程2执行 printf("Child2 process: "); printf("PID=%d PPID=%d \n",getpid(),getppid()); } else{ //父进程执行 wait(); wait(); printf("Parent process: "); printf("PID=%d PPID=%d \n",getpid(),getppid()); exit(0); } } } } }
词法分析课程设计
《词法分析》设计说明书 学生姓名 学 号 5011110122 5011110133 5011110128 所属学院 信息工程学院 专 业 计算机科学与技术 班 级 计算机15-1班 信息工程学院 《编译原理及实践》结课大作 业
摘要 编译，简单的说，就是把源程序转换为可执行程序。从hellow worl说程序运行机制里面简单的说明了程序运行的过程，以及一个程序是如何一步步变成可执行文件的。在这个过程中，编译器做了很多重要的工作。对于编译的内部实现，也就是编译的原理。 这篇论文主要说的是编译器前端，词法分析器的原理，最后会给出一个词法分析器的简单实现。 编译简单的说，就是把源程序转化为另一种形式的程序,而其中关键的部分就是理解源程序所要表达的意思，才能转化为另一种源程序。 可以用一个比喻来说明问题：人A和人B想要交谈，但是他们都不知道彼此的语言，这就需要一个翻译C，同时懂得A和B的语言。有了C做中间层，A和B才能正常交流。C的作用就有点像编译器，它必须能理解源程序所要表达的意思，才能把信息传递给另一个。编译器也一样，它的输入是语言的源文件（一般可以是文本文件）对于输入的文件，首先要分离出这个输入文件的每个元素（关键字、变量、符号、、），然后根据语言的文法，分析这些元素的组合是否合法，以及这些组合所表达的意思。 程序设计语言和自然语言不一样，都是用符号来描述，每个特定的符号表示特定的意思，而且程序设计语言是上下文无关的。上下文无关就是某一个特定语句所要表达的意思和它所处的上下文没有关系，只有它自身决定。 这篇论文主要说的就是词法分析，也就是把输入的符号串整理成特定的词素。 关键词：单片机；词法分析
浙工大过程控制实验报告
浙工大过程控制实验报告 202103120423徐天宇过程控制系统实验报告 实验一：系统认识及对象特性测试 一实验目的 1了解实验装置结构和组成及组态软件的组成使用。 2 熟悉智能仪表的使用及实验装置和软件的操作。 3熟悉单容液位过程的数学模型及阶跃响应曲线的实验方法。 4学会有实际测的得单容液位过程的阶跃响应曲线，用相关的方法分别确定它们的参数，辨识过程的数学模型。二实验内容 1 熟悉用MCGS组态的智能仪表过程控制系统。 2 用阶跃响应曲线测定单容液位过程的数学模型。三实验设备 1 AE2000B型过程控制实验装置。 2 计算机，万用表各一台。 3 RS232-485转换器1只，串口线1根，实验连接线若干。四实验原理 如图1-1所示，设水箱的进水量为Q1，出水量为Q2，水箱的液面高度为h，出水阀V2固定于某一开度值。根据物料动态平衡的关系，求得： 在零初始条件下，对上式求拉氏变换，得：
式中，T为水箱的时间常数（注意：阀V2的开度大小会影响到水箱的时间常数），T=R2*C，K=R2为单容对象的放大倍数， R1、R2分别为V1、V2阀的液阻，C 为水箱的容量系数。 阶跃响应曲线法是指通过调节过程的调节阀，使过程的控制输入产生一个阶跃变化，将被控量随时间变化的阶跃响应曲线记录下来，再根据测试记录的响应曲线求取输入输出之间的数学模型。本实验中输入为电动调节阀的开度给定值OP，通过改变电动调节阀的开度给定单容过程以阶跃变化的信号，输出为上水箱的液位高度h。电动调节阀的开度op通过组态软件界面有计算机传给智能仪表，有智能仪表输出范围为：0~100%。水箱液位高度有由传感变送器检测转换为4~20mA的标准信号，在经过智能仪表将该信号上传到计算机的组态中，由组态直接换算成高度值，在计算机窗口中显示。因此，单容液位被控对象的传递函数，是包含了由执行结构到检测装置的所有液位单回路物理关系模型有上述机理建模可知，单容液位过程是带有时滞性的一阶惯性环节，电动调节阀的开度op，近似看成与流量Q1成正比，当电动调节阀的开度op为一常量作为阶跃信号时，该单容液位过程的阶跃响应为 需要说明的是表达式（2-3）是初始量为零的情况，如果是在一个稳定的过程下进行的阶跃响应，即输入量是在原来的基础上叠加上op的变化，则输出表达式是对应原来输出值得基础上的增
操作系统实验一模拟进程状态转换
实验一模拟进程状态转换及其PCB的变化 一、实验目的： 自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。 二、实验内容及要求： （1）、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。 （2）、独立编写、调试程序。进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。（3）、合理设计与进程PCB相对应的数据结构。PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。 （4）、设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。 （5）、代码书写要规范，要适当地加入注释。 （6）、鼓励在实验中加入新的观点或想法，并加以实现。 （7）、认真进行预习，完成预习报告。 （8）、实验完成后，要认真总结，完成实验报告。 三、实现: 数据结构 struct PCB{
char name; int priority; int needtime; bool operator < (const PCB &b) const{ return priority>b.priority; } }; 五状态进程模型 最高优先数优先调度算法流程图
四、运行结果：
图1创建2个进程，因为这时cpu空闲所以内核调度，b优先级高先执行 图2超时，因为这时cpu空闲所以内核调度，b优先级还是比a高所以先执行
图32个进程均被阻塞，其中一旦进程被阻塞就会引发调度 图4唤醒1个进程，从阻塞队列取队首放到就绪队列队尾，由于这时cpu空闲所以内核调 度
实验1进程的控制与描述资料
实验1 进程的控制与描述 1.1 Windows任务管理器的进程管理 1.1.1 背景知识 Windows 的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息，也显示了最常用的度量进程性能的单位。使用任务管理器．可以打开监视计算机性能的关键指示器，快速查看正在运行的程序的状态，或者终止已停止响应的程序。也可以使用多个参数评估正在运行的进程的活动，以及查看CPU和内存使用情况的图形和数据。其中： （1）“应用程序”选项卡显示正在运行程序的状态，用户能够结束、切换或者启动程序。（2）“进程”选项卡显示正在运行的进程信息。例如，可以显示关于CPU和内存使用情况、页面错误、句柄计数以及许多其他参数的信息。 （3）“性能”选项卡显示计算机动态性能，包括CPU和内存使用情况的图表，正在运行的句柄、线程和进程的总数、物理、核心和认可的内存总数（KB）等。 1.1.2 实验目的 通过在windows任务管理器中对程序进程进行响应的管理操作系统进程管理的概念，学习观察操作系统运行的动态性能。 1.1.3工具／准备工作 在开始本实验之前，请回顾教科书的相关内容。 需要准备一台运行windows 7操作系统的计算机。 1.1.4 实验内容与步骤 启动并进入Windows环境，按Ctrl+A1t+DeL键，或者右键单击任务栏，快捷菜单中单击“任务管理器”，打开“任务管理器”窗口。 在本次实验中，你使用的操作系统版本是： 在当前机器中，由你打开、正在运行的应用程序有：
Windows“任务管理器”的窗口由个选项卡组成，分别是： 当前“进程”选项卡显示的栏目分别是（可移动窗口下方的游标/箭头，或使窗口最大化进行观察）： （1）使用任务管理器终止进程 步骤1：单击“进程”选项卡，一共显示个进程。请试着区分一下，其中：系统(system)进程有个，填入表2-1中。 表2-1 实验记录
编译原理词法分析--A__状态转换图-直接转向法-伪代码描述
int code, value; strToken := ““; GetChar(); //将下一字符读入ch中, 搜索指示器前移一个字符位置 GetBC(); //检查ch中的字符是否为空白,若是调用GetChar直至读入非空白字符if (IsLetter())//判断ch中的字符是否为字母 begin while (IsLetter() or IsDigit()) begin Concat(); //将ch中的字符连接到strToken之后 GetChar(); End Retract(); //将搜索指示器回退一个字符位置, 将ch置为空 code = Reserve(); //对strToken中的字符串查找保留字表,若是,返回编码;否则返回0 if (code = 0) begin value := InsertId(strToken); //将strToken中的标识符插入符号表,返回指针 return ($ID, value); end else return (code, -); end else if (IsDigit())//判断ch中的字符是否为数字 begin while (IsDigit)) begin Concat(); GetChar(); End Retract(); Value := InsertToken(); //将strToken中的标识符插入常数表,返回指针 return ($INT, value); end else if (ch = ‘=’)return ($ASSIGN, -); else if (ch = ‘+’)return ($PLUS, -); else if (ch = ‘*’) begin GetChar(); if (ch = ‘*’) return ($POWER,-); Retract(); return ($STAR,-); end else if (ch = ‘;’)return ($SEMICOLON, -); else if (ch = ‘(’)return ($LPAR, -);
过程控制实验报告
《过程控制实验》 实验报告
第一章、过程控制实验装置的认识 一、过程控制实验的基本内容及概述 本次过程控制实验主要是对实验室的水箱水位进行控制。水箱液位控制系统是一个简单控制系统，所谓简单液位控制系统通常是指由一个被控对象、一个检测变送单元（检测元件及变送器）、以个控制器和一个执行器（控制阀）所组成的单闭环负反馈控制系统，也称为单回路控制系统。 简单控制系统有着共同的特征，它们均有四个基本环节组成，即被控对象、测量变送装置、控制器和执行器。 图1-1 水箱液位控制系统的原理框图 这是单回路水箱液位控制系统，单回路调节系统一般指在一个调节对象上用一个调节器来保持一个参数的恒定，而调节器只接受一个测量信号，其输出也只控制一个执行机构。本系统所要保持的恒定参数是液位的给定高度，即控制的任务是控制水箱液位等于给定值所要求的高度。 二、主要设备 1）水路装置的认识 过程控制实验用的水路装置图如下
图1-2 水路图 由水路装置图我们看到，装置主要有水箱，交流电动泵，热炉，管道，电动阀，电磁阀，流量计，液位传感器，温度传感器组成，可以构成一个完整的过程控制实验平台。从上图我们可以看出，装置主要分为两大部分，第一水路，管道，热炉，水箱等等物理对象，第二是传感器，执行机构等等的控制部分的装置。 实验装置具体介绍如下：
b)电气连接图 由电气装置的图我们可以看到，所有的电器连接都在这里，主要是一些传感器信号，电动驱动信号，用于电动装置的驱动。 见附件 c）操作面板图： 从操作面板上我们可以看到主要是由四个表，由P909构成，用于测量控制压力、流量、液位、温度的测量以及控制，PV代表反馈测量，外给定可以用于串级控制，OUT用于输出信号，以上接口均使用4-20mA标准 见附件 第二、三章、实验系统的认知（包括力控软件，P909，实验装置） a）力控软件的安装 首先使用光盘里的Setup.exe安装力控软件的主题部分，然后将IO Servers文件夹拷到力控软件的安装目录下，安装IO Servers驱动 然后打开力控软件，寻找到力控软件的目录，点击开发模式，然后找到COM设置的部分，如图