请教一个不复杂的模拟单处理器情况下的进程调度的问题

[tianyalangke2003]

目的：模拟单处理器情况下的进程调度
题目：设计一个按优先数进行调度的程序，假定系统中有5个进程，每个进程用一个PCB代表，PCB结构为：进程明，要求运行时间，优先数，状态指针。调度时总让优先数大的进行先执行，有两种状态：就绪和结束，进程每运行一次，优先数减1，要求运行时间减1，当要求运行时间为0时 ,将其状态改为结束，退出就绪队列。重复上述过程直至就绪队列为空。
请用c语言写出源代码,感谢~~verymuch,急用!

[tianyalangke2003]

Gandolf(中国极客)
你不会就算拉
何必在这里说风凉话~~
哎~~~我第一个问题就如此遭遇,看来这里的人不是水平不够就是都很"好人"!!
大家都想帮我省掉"问题点数： 50 "
为此,我真是诚惶诚恐,受宠若惊,真是担当不起啊~~

[Gandolf]

请立即往我的银行账户里汇100万美元，感谢~~verymuch,急用!

[tianyalangke2003]

非常感谢 noproblem_jyb(noproblem) 和hproof(hproof)
因为我才刚看到，所以noproblem_jyb(noproblem) 我就没来得及回复拉
严重感谢hproof(hproof)
本想立刻给你50点的，但给了你这个贴就算结束拉
就无法再问拉，所以还是等我弄懂了再给你加拉
其中问题1 Init();//我找过c的库函数结果没找到啊，这个函数是怎么来的啊，什么作用啊
问题2 for(int i=0; i<5; i++)
{
sprintf(buf, "proc %d", i);
Start(buf, 10+i, 10, PS_RUN);//这里为什么level是10+i，而time是10呢，为何不是其他的呢，这个是否有什么规律啊
问题3 State[ 2 2 2 2 1 ] Level[ 4 4 4 4 4 ] Runned[ 4]
请问为何这里第4个进程的状态是1，好象这并不是你函数里的东西决定的啊，是电脑自己搞的吗
问题4 // 找到具备最大优先及的进程
for(i=0; i<MAX_PROCESS; i++)
{
if(process[i].state == PS_RUN)
{
max = i;/*由于上面的i是随循环而改变，那max岂不是也一起改变吗？我觉得只要一次“for(i=0; i<MAX_PROCESS; i++)”就可找到最大的拉，为何还要用
“for(; i<MAX_PROCESS; i++)”呢*/
for(; i<MAX_PROCESS; i++)
{
if(process[i].state==PS_RUN && process[i].level>process[max].level ) max = i;
}
}
}


以上问题还要dx多多指教啊，谢谢

[hproof]

问题1：Init() 是我自己编的一个函数，在上面已经个出了，你再仔细找找；

问题2：Start(buf, 10+i, 10, PS_RUN);//这里为什么level是10+i，而time是10呢……
答案：time=10是为了让他们能有足够的运行时间；
level=1+i，是因为由于至少需要10个周期才能运行完该程序，那么在第10周期时，level肯定已经减了10次了，所以最好让level大于10；
为了表现不同的优先及，所以加上了i；

问题3 State[ 2 2 2 2 1 ] Level[ 4 4 4 4 4 ] Runned[ 4] 为什么状态是1？
答案：这是由运行而决定的，这里给出的包括了上面、下面一行的记录：
State[ 2 2 2 2 2 ] Level[ 4 4 4 4 5 ] Runned[ 3] （1）
State[ 2 2 2 2 1 ] Level[ 4 4 4 4 4 ] Runned[ 4] （2）提问行
State[ 2 2 2 2 1 ] Level[ 3 4 4 4 4 ] Runned[ 0] （3）
看第1行，由state知道，5个进程都处于“运行”状态，由level知道，进程4优先及最高，所以第2行中的runned为4；
看第2行，由state知道，第4个进程已经结束，状态为1，由level知道，各进程优先及相同，所以第3行中的runned为0，即PCB列表中的第一个进程；（其它类似）

问题4：这确实是个bug！！！！！！！需要在 if(process[i].state == PS_RUN){}中加上一条break语句；


// 哈哈，你这么认真，怎么会写不出这个程序呢？一定是偷懒也。。。

[hproof]

问题3 State[ 2 2 2 2 1 ] Level[ 4 4 4 4 4 ] Runned[ 4]
请问为何这里第4个进程的状态是1，好象这并不是你函数里的东西决定的啊，是电脑自己搞的吗？


// 看一下 int Run() 函数的定义处，那里有：
if(process[max].time <= 0) process[max].state = PS_STOP;

这样就修改了进程4的状态为1；（因为进程4的优先及初始为 10+i=14 最高，所以最先停止）

[tianyalangke2003]

哦。明白拉，非常感谢感谢啊~~~哦，这样的啊
呵呵，不好意思，还有不明白的地方啊
问题1 // 运行该进程
if(process[max].level > 0) process[max].level --;
process[max].time --;
if(process[max].time <= 0) process[max].state = PS_STOP;

return max;
自加自减来描述的，但实际中的进程的运行不是这样的吧！
那程序如何得知cpu 有没有运行进程呢啊，如果是程序需要接受进程运行过的信号，那是否要写上
特定的接受信号的函数呢？那这个函数为何你不写上去呢？
问题2 // 找到具备最大优先及的进程
for(i=0; i<MAX_PROCESS; i++)
这里为何定义max-process为32而不是5呢

谢谢

[tianyalangke2003]

还有，我很“// 哈哈，你这么认真，怎么会写不出这个程序呢？一定是偷懒也。。。笨的啊”
其实我只看过谭豪强的c语言设计，其他方面的都还没看过，所以还要dx多多指教，请不要嫌弃我烦啊

还有东西要问，dx可否加我qq啊，在qq上说比较方便啊，呵呵
我的qq是： 82126952

[hproof]

问题1：实际进程当然不是这样的，这里只是给出最简单的例子——我只为了接分。
关于处理函数，处理起来比较麻烦，如“抢先式”、“非抢先式”等，最麻烦的是需要“保护进程环境”，至少包括进程当前执行处的“指令指针”，还有其它主要寄存器。这些可以在PCB结构中改进；
所以在这里，只是简单的带过，把重点放在“调度模拟”上。你不会是想写一个操作系统吧？？？？

问题2：为何定义max-process为32而不是5呢？
答案：这些是随便定义的啦，因为以前UNIX中是32，所以就32咯（当然，for循环中必须使用MAX_PROCESS 而不是 5， 因为我们不知道实际建立了多少个进程）。

[tianyalangke2003]

哦，不明白啊
我从页面右上方进入“管理”，然后在你的帖子右边处输入分数值。

再在页面上方输入密码，点击“给分”，然后提示结贴，我也确定拉，但还是没给分啊！！！
晕~~`

[noproblem_jyb]

So easy!
关键是，你想实现出的模型是协作式还是抢占式，就像Windows32和Win95的区别。
我可以写，但要一些时间，今天晚上大约9点，我把程序贴上来。
如果你要的话，在中午12点前回应一下。

[cochen]

learning!

[hproof]

太简单了，没兴趣~

[hproof]

无聊，帮你写了一个：

// abc.cpp

// define...
#define MAX_PCB_NAME 12 // 进程最大名字长度
#define MAX_PROCESS 32 // 允许最大的进程数

// include...
#include "stdio.h"
#include "string.h"

// 进程状态
enum PCB_STATE
{
PS_NONE,
PS_STOP,
PS_RUN
};

// PCB结构
typedef struct PCB
{
char name[MAX_PCB_NAME];
int time;
int level;
PCB_STATE state;
}PCB, *LPPCB;

// Global...
PCB process[MAX_PROCESS];

// 初始化进程列表
void Init()
{
int i;
for(i=0; i<MAX_PROCESS; i++)
{
process[i].state = PS_NONE;
}
}

// 返回被执行的进程id，-1表示没有任何进程可以执行
int Run()
{
int i = 0;
int max = -1;

// 找到具备最大优先及的进程
for(i=0; i<MAX_PROCESS; i++)
{
if(process[i].state == PS_RUN)
{
max = i;
for(; i<MAX_PROCESS; i++)
{
if(process[i].state==PS_RUN && process[i].level>process[max].level ) max = i;
}
}
}
if(max == -1) return -1;

// 运行该进程
if(process[max].level > 0) process[max].level --;
process[max].time --;
if(process[max].time <= 0) process[max].state = PS_STOP;

return max;
}

// 开始一个进程，并返回进程id，-1表示没有进程被建立
int Start(char *name, int level, int time, PCB_STATE state)
{
int id = -1;
int i;

for(i=0; i<MAX_PROCESS; i++)
{
if(process[i].state == PS_NONE)
{
process[i].state = state;
process[i].level = level;
strcpy(process[i].name, name);
process[i].time = time;
id = i;
break;
}
}
return id;
}

// 用于输出状态，包括前5个进程的状态，优先及，当前运行id
void Dump(int id)
{
int i;
char buf[256];
char tmp[256];


sprintf(buf, "State[");
for(i=0; i<5; i++)
{
sprintf(tmp, "%2d ", process[i].state);
strcat(buf, tmp);
}

strcat(buf, "]\tLevel[");
for(i=0; i<5; i++)
{
sprintf(tmp, "%2d ", process[i].level );
strcat(buf, tmp);
}

strcat(buf, "]\tRunned[");
sprintf(tmp, "%2d", id);
strcat(buf, tmp);
strcat(buf, "]\n");

printf(buf);
}


void main()
{
int id;
char buf[256];

Init();
for(int i=0; i<5; i++)
{
sprintf(buf, "proc %d", i);
Start(buf, 10+i, 10, PS_RUN);
}

while(1)
{
id=Run();
if(id==-1) break;

Dump(id);
}
}
====================================================
附程序输出（只显示前5个进程）
查看方法：State表示状态2=运行，1=停止，0=无效
Level表示优先及，
Runned 表示上次运行的进程id，它是由上面一行中的level决定的

State[ 2 2 2 2 2 ] Level[10 11 12 13 13 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[10 11 12 12 13 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[10 11 12 12 12 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[10 11 11 12 12 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[10 11 11 11 12 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[10 11 11 11 11 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[10 10 11 11 11 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[10 10 10 11 11 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[10 10 10 10 11 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[10 10 10 10 10 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 9 10 10 10 10 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 9 9 10 10 10 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 9 9 9 10 10 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 9 9 9 9 10 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[ 9 9 9 9 9 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 8 9 9 9 9 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 8 8 9 9 9 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 8 8 8 9 9 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 8 8 8 8 9 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[ 8 8 8 8 8 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 7 8 8 8 8 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 7 7 8 8 8 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 7 7 7 8 8 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 7 7 7 7 8 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[ 7 7 7 7 7 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 6 7 7 7 7 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 6 6 7 7 7 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 6 6 6 7 7 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 6 6 6 6 7 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[ 6 6 6 6 6 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 5 6 6 6 6 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 5 5 6 6 6 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 5 5 5 6 6 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 5 5 5 5 6 ] Runned[ 3]
State[ 2 2 2 2 2 ] Level[ 5 5 5 5 5 ] Runned[ 4]
State[ 2 2 2 2 2 ] Level[ 4 5 5 5 5 ] Runned[ 0]
State[ 2 2 2 2 2 ] Level[ 4 4 5 5 5 ] Runned[ 1]
State[ 2 2 2 2 2 ] Level[ 4 4 4 5 5 ] Runned[ 2]
State[ 2 2 2 2 2 ] Level[ 4 4 4 4 5 ] Runned[ 3]
State[ 2 2 2 2 1 ] Level[ 4 4 4 4 4 ] Runned[ 4]
State[ 2 2 2 2 1 ] Level[ 3 4 4 4 4 ] Runned[ 0]
State[ 2 2 2 2 1 ] Level[ 3 3 4 4 4 ] Runned[ 1]
State[ 2 2 2 2 1 ] Level[ 3 3 3 4 4 ] Runned[ 2]
State[ 2 2 2 1 1 ] Level[ 3 3 3 3 4 ] Runned[ 3]
State[ 2 2 2 1 1 ] Level[ 2 3 3 3 4 ] Runned[ 0]
State[ 2 2 2 1 1 ] Level[ 2 2 3 3 4 ] Runned[ 1]
State[ 2 2 1 1 1 ] Level[ 2 2 2 3 4 ] Runned[ 2]
State[ 2 2 1 1 1 ] Level[ 1 2 2 3 4 ] Runned[ 0]
State[ 2 1 1 1 1 ] Level[ 1 1 2 3 4 ] Runned[ 1]
State[ 1 1 1 1 1 ] Level[ 0 1 2 3 4 ] Runned[ 0]
Press any key to continue