操作系统 进程源代码

#include
#include
#include

#define TRUE 1
#define FALSE 0
#define MAXPRI 100
#define MAX 9
#define NIL -1
#define USE 0
#define UNUSE -1

struct {
int id;//进程身份(即:内部标识符，如:0,1,2)
char status;//进程状态，可为E、R、T、W和C；
//系统为进程设置了5种运行状态：
//E -- 执行态；
//R -- 高就绪态；
//T -- 低就绪态(执行进程因时间片到限而转入)；
//W -- 等待态；
//C -- 完成态。
//各进程的初始状态均设置为R。
int nextwr; //等待链指针,指示在同一信号量上等待的下一个进程的标识数。
int priority;//进程优先数；
int flags; //用于标志此PCB是否可用：
//(USE表示PCB已创建 or UNUSE表示PCB未创建)
int identify;//外部标识符
}
pcb[MAX]; //PCB[i]的信息
struct {
int value; //信号量值，初值为1
int firstwr;//等待链首指针，指示该信号量上等待的第一个进程的标识数
}
sem[2]; //信号量的信息
struct {
int comer; //信息发送者(send message)
int info_num;//发来得信息数(messages's number)
int mutex; //信箱同步信号量(USE表示信箱可使用 or UNUSE表示信箱不可使用)
int boxflag;//信箱存在否的标志
}
box[MAX]; //进程i的信箱
char savearea[MAX][4],addr;//现场保留区，用数组SAVEAREA[MAX][4]表示。
//即每个进程都有一个大小为4个单元的保留区，用来保存被"中断"时的现场信息，
//如通用寄存器的内容和断点地址等。
int s1,s2;
//两个公共变量，用作共享临界资源。
int i; //用来模拟一个通用寄存器；
int seed;
int exe=NIL;//执行进程指针,其值为进程标识数；
int count[MAX+1];//可用PCB索引：
//其中:count[0..MAX-1]分别标识pcb[0..MAX-1](1为存在,0反之)
//count[MAX]为还可创建的PCB个数
int remark=1; //用于记录外部标识符的标识数
int wentdown[3*MAX];//用于记录已撤消的进程号
int cx;//已撤消的进程数组计数器

//***函数声明***
void init(); //初始化创建原语
int find(); //从就绪队列中选择一进程变

为执行态
int p (int se,char ad); //p操作
int v (int se, char ad); //v操作
void create(); //创建原语
void deleted(int n); //撤消原语
void block (int se); //阻塞原语
void wakeup (int se); //唤醒原语
void eexit (int n); //进入终止态
void process(); //各进程须完成的操作流程
int scheduler(); //操作系统的进程调控
void analyse(); //判断是否添加新进程
bool timeint(char ad); //时间片中断函数
void time_silk(); //时间片单元函数(细分时间片到每一步)
void call_time(); //调用时间函数
void inform(); //发送消息函数(进程通信)
void recive(); //接收消息函数
//***

void init() // Initialization
{
//%%%%%为进程创建PCB %%%%%
for(int j=0; j<3; j++)
{
pcb[j].id =j; //给进程身份(如：1，2，3...)赋值
pcb[j].status ='r';//进程状态(可为E、R、T、W和C)
//R -- 高就绪态；
pcb[j].nextwr =NIL;//等待链指针,指示在同一信号量上等待的下一个进程的标识数。
printf("\n Process %d priority?",j+1);//***输入各进程优先级***
scanf("%d",&i);
pcb[j].priority=i; //***
pcb[j].identify=j+1;//外部标识符
pcb[j].flags=USE; //标识PCB已创建
count[j]=1; //***修改'可用PCB索引'***
count[3]--; //*****
remark++; //修改'外部标识符的标识数'的记录
box[j].mutex=USE;//信箱可使用
box[j].boxflag=USE;
}
//%%%%%————————%%%%%

//#####为各信号量赋初值#####
sem[0].value=1;
sem[0].firstwr=NIL;
sem[1].value=1;
sem[1].firstwr=NIL;
//#####————————#####

for(i=0; i//用数组SAVEAREA[MAX][4]表示***
for(j=0; j<4; j++)
savearea[i][j]='0'; //***

for(j=0;j<3*MAX;j++) //***已撤消的进程数组为空***
wentdown[j]=-1; //***
cx=0;

//&&&&&&&&-------------&&&&&&&&&&&
for(j=3;j{
pcb[j].status ='c';
pcb[j].flags=UNUSE;
box[j].mutex=USE;
box[j].boxflag=UNUSE;
pcb[j].identify=-1;
}
for(j=3;j{
count[j]=0;
} //**************************
//&&&&&&&&--------------&&&&&&&&&&
count[MAX]=MAX-3; //还创建的PCB个数
}

double random() //产生随机数的程序，表明各进程行动的异步性
{
int m;

if(seed<0) m=-seed;
else m=seed;

seed=(25173 * seed +13849) % 65536;

return (m / 32767.0);
}


bool timeint (char ad) /* Time slice interrupt */
{
double x;

x=random();

for(double yi=0.00;yi<1.00;yi+=(1.00/MAX))
if((x
//***现场保留区***
savearea[exe][0]=i; //记录程序执行到的地方(即:该程序执行到了第几圈)
savearea[exe][1]=ad;//记录时间片用完时程序所处的状态

pcb[exe].status='t';//PCB中记录程序因Time slice用完而中断
//******

printf("\tTime slice interrupt .\n\tprocess %d enter into ready.\n",pcb[exe].identify);

exe=NIL; //记录当前正在运行的进程为无

return (TRUE);
}


int scheduler ()
{
int pd;

if(count[MAX]!=0) //分析是否创建进程
analyse();

if((pd = find()) == NIL && exe == NIL) //判断是否退出系统
return (NIL); /* Quit system */

if(pd != NIL)
{
if(exe == NIL)//***若当前执行程序为无***
{
pcb[pd].status='e';//将状态变为执行态
exe=pd;
call_time(); //调用时间
printf("Process %d is executing.\n",pcb[exe].identify);
recive(); //收消息
inform(); //发消息

} //******
else //***若当前执行程序非空***
if(pcb[pd].priority < pcb[exe].priority)//@@@判断优先级高低@@@
//若优先级高于当前执行程序
{
pcb[exe].status='r';
printf("\tProcess %d enter into ready.\n",pcb[exe].identify);
pcb[pd].status='e'; //将状态变为执行态
exe=pd;
call_time(); //调用时间
printf("Process %d is executing.\n",pcb[exe].identify);
recive(); //收消息
inform(); //发消息
} //@@@@@@
}

i =savearea[exe][0]; //恢复程序执行到的地方(圈数)
addr=savearea[exe][1];

return (exe);
}

int find() //~~~~~寻找应该吊为执行程序的进程~~~~~
{
int j; //用于循环计数
int pd=NIL;//记录应吊为执行态的进程
int w=MAXPRI;//设置一个哨兵来寻找最高优先的进程

for(j=0; jif(pcb[j].status == 'r')
if(pcb[j].priority < w)
{
w =pcb[j].priority;
pd=j;
} //**********

if(pd == NIL) //*****若不存在高就绪，则判断是否存在低就绪*****
for(j=0; jif(pcb[j].status == 't')
if(pcb[j].priority < w)
{
w =pcb[j].priority;
pd=j;
} //****

******

return (pd);//返回应吊为执行态的进程

}

int p (int se,char ad)
{
if(--sem[se].value >= 0) //判断(信号量)临界区是否可进入
return (FALSE);//可，则执行

block(se); //不可，则阻塞
savearea[exe][0]=i; //记录程序执行到的地方
savearea[exe][1]=ad;//记录时间片用完时程序所处的状态
exe=NIL; //

return (TRUE);
}

void block (int se)
{
int w;

printf("\tProcess %d is block.\n",pcb[exe].identify);

pcb[exe].status='w'; //将程序PCB置为等待态
pcb[exe].nextwr=NIL; //等待链指针，\
//指示在同一信号量上等待的下一个进程的标识数
//***等待链首指针，指示该信号量上等待的第一个进程的标识数***
if((w = sem[se].firstwr) == NIL)
sem[se].firstwr=exe;
//***firstwr***

//等待链指针，指示在同一信号量上等待的下一个进程的标识数
else
{
while(pcb[w].nextwr != NIL)
w=pcb[w].nextwr;
pcb[w].nextwr=exe;
}
//***nextwr***

pcb[exe].priority--;
printf(" **********pcb[%d].priority=%d*********\n",pcb[exe].identify,pcb[exe].priority);
return;
}

int v (int se, char ad)
{
if(++sem[se].value > 0)//判断(信号量)临界区是否可进入
return (FALSE); //不可，则继续阻塞

wakeup(se); //可，则唤醒
savearea[exe][0]=i;//记录程序执行到的地方
savearea[exe][1]=ad;//记录时间片用完时程序所处的状态
return (TRUE); /* scheduler */
//开始执行
}

void wakeup (int se)
{
int w;

w=sem[se].firstwr;
//给'等待链首指针(指示该信号量上等待的第一个进程的标识数)'赋值

if(w != NIL)
{
sem[se].firstwr=pcb[w].nextwr;
//赋'等待链指针(指示在同一信号量上等待的下一个进程的标识数)'值\
///给'等待链首指针(指示该信号量上等待的第一个进程的标识数)'
pcb[w].status='r';//状态变为低就绪
printf("\tProcess %d is waken up.\n",pcb[w].identify);
}

}

void process ()
{
if(addr == 'a') goto a1;
if(addr == 'b') goto b1;
if(addr == 'c') goto c1;

if(addr == 'd') goto d1;
if(addr == 'e') goto e1;
if(addr == 'f') goto f1;

for(i=1; i<6; i++)
{
printf("\tprocess%d calls P on the semaphore 1.\n",pcb[exe].identify);
time_silk();
if(p(0,'a')) break; /* Process1 is blocked */

a1:
printf("\tprocess%d is executing in the cretical section 1.\n",pcb[exe].identify);
time_silk();
if(timeint('b')) break;

/* Time silce interrupt */

b1:
printf(" s1=%d\n",++s1);
printf("\tprocess%d calls V on semaphore 1 and quit cetical section 1.\n",pcb[exe].identify);
time_silk();
if(v(0,'c')) break; /* Wake up a blocked process */

c1:
printf("\tprocess%d calls P on semaphorel 2.\n",pcb[exe].identify);
time_silk();
if(p(1,'d')) break;

d1:
printf("\tprocess%d is executing cretical section 2.\n",pcb[exe].identify);
time_silk();
if(timeint('e')) break;

e1:
printf(" s2=%d\n",++s2);
printf("\tprocess%d calls V on semaphore 2 and quit cretical section 2.\n",pcb[exe].identify);
time_silk();
if(v(1,'f')) break; /* Wake up a block process */

f1:
printf(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
printf("\tprocess%d cycle count =%d\n",pcb[exe].identify,i);
printf(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}

if(i < 6)
return;
eexit(exe);
}


void eexit (int n)
{
pcb[n].status='c';//PCB状态变为终止态
printf("Process %d is completed!\n",pcb[n].identify);
deleted(n);
exe=NIL;//记录当前正在运行的进程为无
}

void main ()
{
int k;

printf("********* Process Management **********\n\n");
init();
printf("s1=%d, s2=%d\n",s1,s2);
printf("Process1,Process2,Process3 are all in ready !\n");

for( ; ; )
if((k=scheduler()) != NIL)
process();
else
break;
printf(" \ts1=%d, s2=%d\n",s1,s2);
printf("\n ********* END **********\n");
} /* end */


void deleted(int n)
{
pcb[n].flags=UNUSE;//撤消PCB
count[n]=0; //***修改'可用PCB索引'***
count[MAX-1]++; //*****
wentdown[cx]=pcb[n].identify;//***记录被撤消进程***
cx++; //*****
box[n].boxflag=UNUSE;
printf("process%d has been deleted!",pcb[n].identify);
}

void create()
{
int rep;
int pri;
for(int j=0;j{
if(count[j]==0)
{
rep=j;
break;
}
}
pcb[rep].id =rep; //给进程身份(如：1，2，3...)赋值
pcb[rep].status ='r';//进程状态(可为E、R、T、W和C)
//R -- 高就绪态；
pcb[rep].nextwr =NIL;//等待链指针,指示在同一信号量上等待的下一个进程的标识数。
printf("Process %d priority?",remark);//***输入各进程优先级***
scanf("%d",&pri);
pcb[rep].priority=pri; //***
pcb[rep].identify=remark;//外部标识符
pcb[rep].flags=USE; //标识PCB已创建
box[rep].boxflag=USE;
count[rep]=1; //***修改'可用PCB索引'***
count[MAX]--; //*****
remark++; //

修改'外部标识符的标识数'的记录

for(j=0; j<4; j++) //***恢复初始态***
savearea[rep][j]='0'; //******
}

void analyse()
{
char answer;//用于记录"外存是否还有作业需创建进程"的响应
printf("\nDo you want to create a new process?(Y/N)");
TRY:cin>>answer;//取得响应值
if(answer=='y'||answer=='Y')
create();
else if(answer=='n'||answer=='N')
return;
else
{
printf("\nThe answer is wrong!Try again...");
goto TRY;
}

int pcb_use_count=0; //用于寻找可用PCB数量
for(int pcbf=0;pcbf{
if(pcb[pcbf].flags==UNUSE)
pcb_use_count++;
} //*****************
if(pcb_use_count!=0)
{
printf("\nDo you want create another onr?answer:");
goto TRY;
}
}

void call_time()//调用时间函数
{
/*unsigned int t,s,k;
for(t=0;t<6000;t++)
for(s=0;s<6000;s++)
for(k=0;k<20;k++);*/
}

void time_silk()//时间片函数
{
/*unsigned int t,s,k;
for(t=0;t<11;t++)
for(s=0;s<6000;s++)
for(k=0;k<6000;k++);*/
}

void inform()
{
char require;
printf("\tDo you want to send message?");
TRY: cin>>require;//取得响应值
if(require=='y'||require=='Y')//*********答案***********
{
int geter;
int number;
printf("\t\tWho will recive the message? prosess");
BACK:cin>>geter;
int policeman=-1; //***检验geter是否被撤消***
for(int pi=0;piif(wentdown[pi]==geter)
policeman=1; //******
if((geter>=remark)||(policeman==1)) //***检验进程是否存在***
{
printf("\t\t!!!^^WARNING:^^!!!\n");
printf("\t\t this process not exist! please check and input again:process");
goto BACK;
} //******
printf("\t\tHow many messages will be gave?");
cin>>number;
for(int mi=0;mi{
if(pcb[mi].identify==geter)
geter=pcb[mi].id;
}
if(box[geter].boxflag==USE)
//*****判断信箱是否为空*****
if(box[geter].mutex==USE) //是,发送
{
box[geter].mutex=UNUSE;
box[geter].info_num=number;
box[geter].comer=pcb[exe].id;
printf("\t\t$@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@$\n");
printf("\t\t SUCCEESS!!! WONDERFUL!!!\n");
printf("\t\t$@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@$\n");
}
else //否,失败
{
printf("\t\t$@@@@@@@@@@@@@@@@@@

@@@@@@@@@@$\n");
printf("\t\t FAILED!!! GO ON!!!\n");
printf("\t\t$@@@@@@@@@@@@@@@@@@@@@@@@@@@@$\n");
return;
}
}
else if(require=='n'||require=='N')//**********答案************
return;
else //**********答案************
{
printf("\nThe require is wrong!Try again...");
goto TRY;
}
//***^^^ ^^^***
}

void recive()
{
if(box[exe].mutex==UNUSE)
{
printf("\t$^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^$\n");
printf("\t I have recive process%d's messages!!! messages'number is%d.\n",
pcb[box[exe].comer].identify,box[exe].info_num);
printf("\t$^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^$\n");
box[exe].mutex=USE; //清空信箱
}
else
return;
}