生产调度课程

⑴ 操作系统课程设计《两道批处理系统的两级调度-2》 请发邮箱[email protected]，多谢各位大神啦！

设计1 进程管理
设计内容
进程的创建和控制
编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。每个进程在屏幕上显示一个字符，记录屏幕上的显示结果，并分析原因。修改以编写的程序，将每个进程输出一个字符改为每个进程输出一句话。
进程的软中断通信
使用系统调用fork()创建两个子进程，使用系统调用signal（）让父进程捕捉用alarm函数设置时钟的时间段终止时产生的信号，当捕捉到该信号后，父进程使用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出子进程被杀死信息后终止，父进程等待两个子进程终止后，输出父进程被杀死信息后终止程序。记录屏幕上的显示结果，并分析原因。
进程的管道通信
使用系统调用pipe()建立一个管道；两个子进程分别向管道写信息，父进程则从管道读出来自子进程的信息，显示在屏幕上。
记录屏幕上的显示结果，并分析原因。
设计2 进程的同步与互斥
设计内容
用程序实现生产者-消费者问题
问题描述： 一个仓库可以存放K件物品。生产者每生产一件产品，将产品放入仓库，仓库满了就停止生产。消费者每次从仓库中去一件物品，然后进行消费，仓库空时就停止消费。
设计3 存储管理
设计内容
将指令序列转换为用户虚存中的请求调用页面流。
页面大小为1K
用户内存容量为4页到40页
用户外存的容量为40k
在用户外存中，按每K存放10条指令，400条指令在外存中的存放方式为：
0-9条指令为第0页
10-19条指令为第1页
。。。。。
390-399条指令为第39页
按以上方式，用户指令可组成40页
通过随机数产生一个指令序列，共400个指令（0-399）
模拟请求页式存储管理中页面置换算法
执行一条指令，首先在外存中查找所对应的页面和页面号，然后将此页面调入内存中，模拟并计算下列各述算法在不同内存容量下的命中率(页面有效次数/页面流的个数)
先进先出的算法(FIFO)
最久未使用算法(LRU)
提示
随机指令的产生
rand() 或srand()
用户内存中页面控制结构采用链表
页面控制结构
struct p_str{
int pagenum; /* 页号 */
int count; /* 访问页面的次数 */
struct p_str next; /* 下一指针 */
}p_str;
#define false 0
#define true 1
#define n 4
#define m 10
struct
{
char type[10];
int count;
int remain;
int address;
}equiptype[n];
struct
{
int number;
int status;
int remain;
char jobname[4];
int lnumber;
}equipment[m];
allocate(J,type,mm)
char *J,*type;
int mm;
{
int i,t,j;

i=0;
while(i<n&&strcmp(equiptype[i].type,type)!=0)
i++;
if(i>=n)
{
printf("该类设备,设备配失败");
return(false);
}
if(equiptype[i].remain<1)
{
printf("该类设备足配失败");
return(false);
}
t=equiptype[i].address;
while(!(equipment[t].status==1 && equipment[t].remain==0))
t++;

equiptype[i].remain--;
equipment[t].remain=1;
strcpy(equipment[t].jobname,J);
equipment[t].lnumber=mm;
}
reclaim (J,type)
char J,type;
{
int i,t,j,k,nn;
i=0;
while(i<n&&strcmp(equiptype[i].type,type)!=0)
i++;
if(i>=n)
{
printf("该类设备,设备收失败");
return(false);
}
t=equiptype[i].address;
j=equiptype[i].count;
k=0;
nn=t+j;
for(;t<nn;t++)
if(strcmp(equipment[t].jobname,J)==0&&equipment[t].remain==1)
{
equipment[t].remain=0;
k++;
}
equiptype[i].remain= equiptype[i].remain+k;
if(k==0)
printf("该作业没使用该类设备\n");
}
main( )
{
char J[4];
int i,mm,a;
char type[10];

strcpy(equiptype[0].type,"input");
equiptype[0].count=2;
equiptype[0].remain=2;
equiptype[0].address=0;
strcpy(equiptype[1].type,"printer");
equiptype[1].count=3;
equiptype[1].remain=3;
equiptype[1].address=2;
strcpy(equiptype[2].type,"disk");
equiptype[2].count=4;
equiptype[2].remain=4;
equiptype[2].address=5;
strcpy(equiptype[3].type,"tape");
equiptype[3].count=1;
equiptype[3].remain=1;
equiptype[3].address=9;

for(i=0;i<10;i++)
{
equipment[i].number=i;
equipment[i].status=1;
equipment[i].remain=0;
}
while(1)
{
printf("\n0－退1－配2－收3－显示");
printf("\n选择功能项（0~3）:");
scanf("%d",&a);
switch(a)
{
case 0 :
exit(0);
case 1 :
printf("输入作业名、作业所需设备类设备相号");
scanf("%s%s%d",J,type,&mm);
allocate(J,type,mm);
break;
case 2:
printf("输入作业名作业归设备类");
scanf("%s%s",J,type);
reclaim(J,type);
break;
case 3:
printf("\n输设备类表\n");
printf(" 设备类型 设备总量 空闲设备\n");
for(i=0;i<n;i++)
printf("%9s%8d%9d\n",equiptype[i].type,equiptype[i].count, equiptype[i].remain);
printf("输设备表:\n");
printf("绝号 /坏 已/未配 占用作业名 相号\n");
for(i=0;i<m;i++)
printf("%3d%8d%9d%12s%8d\n",equipment[i].number, equipment[i].status,equipment[i].remain,equipment[i].jobname,
equipment[i].lnumber);
}
}
}

⑵ 只要流程图车厢调度问题

通过考察各个站点间的距离，发现每6秒将可能出现车到站的事件。

假设车站总有足够的车发出，考虑单行方向。

Bus_on_e为发车次数，Bus_on_e – bus_on_s为在线车数

初始化t=0

bus_on_e=0;

bus_on_s=0;

站点人数station(i)(j)=0;

站点将下车人数free(i)(j)=0;

开始（以6秒为步长）（每6秒线上将有可能有一辆车到某一站）

站点人数改变:station(i)(j)= station(i)(j)+p(i)(j)*6

站点将下车人数改变:free(i)(j)=free(i)(j)+f(i)(j)*6

遍历所有在线车的位置（车是否到达站点bus_opp(i)?=车站位置）i=bus_on_s:1:bus_on_e

是
否

判断车是否在终点bus_opp(n)?=end?
改变车的位置bus_opp(n)+=(6*20/60)

是
否

减少在线车数量bus_on_s+=1

改变车上人数Num(n)=Num(n)+station(i)(j)-free(i)(j)

车到终点不再行驶bus_opp(n)=10000

改变车的位置bus_opp(n)+=(6*20/60)

计算满意率

计算满意率

判断是否为发车时间（最短发车间隔为60秒）Now-last（上一次发车时间）?=T(发车间隔)

是
否

增加车数bus_on_e+=1，bus_on_e+1即为车的编号

初始化车bus_opp(bus_on_e+1)=0;

初始化车人数为第一站人数Num(bus_on_e+1)=station(i)(1)

结束：t=60*60*18;

⑶ 操作系统这门课程第十章I/O管理和磁盘调度的知识点有哪些

操作系统这门课第十章I/O管理和磁盘调度的知识点包含章节导引,第一节I/O设备及功能,第二节I/O管理设计及I/O缓冲,第三节磁盘调度,第四节RAID,第五节磁盘缓存与LinuxI/O,。

⑷ 运筹学的课程综合性实验报告《航班降落调度》

sets:
plane/1..10/:x,fine,earliest,lastest,target;
link(plane,plane):wait,y;
endsets

data:
!最早到达时间;
earliest=129 195 89 96 110 120 124 126 135 160;

!最晚到达时间;
lastest=559 744 510 521 555 576 577 573 591 657;

!目标时间;
target=155 258 98 106 123 135 138 140 150 180;

!罚金;
fine=10 10 30 30 30 30 30 30 30 30;

!相邻降落之间的间隔时间矩阵;
wait=0 3 15 15 15 15 15 15 15 15 !1;
3 0 15 15 15 15 15 15 15 15 !2;
15 15 0 8 8 8 8 8 8 8 !3;
15 15 8 0 8 8 8 8 8 8 !4;
15 15 8 8 0 8 8 8 8 8 !5;
15 15 8 8 8 0 8 8 8 8 !6;
15 15 8 8 8 8 0 8 8 8 !7;
15 15 8 8 8 8 8 0 8 8 !8;
15 15 8 8 8 8 8 8 0 8 !9;
15 15 8 8 8 8 8 8 8 0; !10;
enddata

min=@sum( plane:fine(i)*@abs( x(i)-target(i) ) );
@for(plane(i):@bnd(earliest(i),x(i),lastest(i)));!最早降落时间和最迟降落时间限制;
@for(plane(i):@for(plane(j) | i#ne#j:y(i,j)=@if(x(i) #le# x(j),1,0)));!飞机i比飞机j早降落，y（i,j）=1，否则为0;
@for(link(i,j) | i#ne#j:(y(i,j)+y(j,i))=1);
@for(plane(i):@for(plane(j) | i#ne#j:x(i)+wait(i,j)<=x(j)));
@for(plane:@gin(x));
@for(link:@bin(y));

这个代码大概可以表示，但是还是有错误，期待高手修改一下。

⑸ 有谁有程控交换的课程设计 周期级调度管理程序设计 具体任务是 1）用户群摘挂机识别程序设计。 2）脉冲号

这个嘛，我不了解！

⑹ 操作系统这门课程第八章单处理器调度的知识点有哪些

操作系统这门课第八章单处理器调度的知识点包含章节导引,第一节进程调度类型及基本概念,第二节调度算法,。

⑺ 操作系统课程设计

完整的设计报告和应用程序，已经发你邮箱了！

⑻ 操作系统课程设计任务书：进程调度算法的设计

哥们不是华航的吧，，怎么都一样的作业啊

⑼ 数据结构课程设计 车厢调度问题

随便测试了点数据, 没发现有什么错误...

#include <stdio.h>
#include <stdlib.h>
#define LEN 16384
typedef char Data;
typedef struct Stack
{
Data *data;
Data *end;
}Stack;
Stack A,B,C,D;
int total;
Data head;
Data end;
Data a,b,c;
int ns;
unsigned long min = 0x7FFFFFFF, count;
char res[LEN], tmp[LEN], *p = tmp;
#define EOD (127)

void Init ( Stack *a, int len )
{
a->data = (Data*) malloc ( len * sizeof(Data) );
memset ( a->data, 0, len * sizeof(Data) );
a->end = a->data - 1;
}
void ReadData ( void )
{
int i;
FILE *fp;
fp = fopen ( "input.txt", "r" );
if ( fp == NULL )
exit ( __COUNTER__ );

fscanf ( fp, "%d", &total );
if ( total < 1 )
{
fclose ( fp );
exit ( __COUNTER__ );
}

Init ( &A, total+1 );
Init ( &B, total+1 );
Init ( &C, total );
Init ( &D, total+1 );
fscanf ( fp, "%s", A.data );
end = head = A.data[0];
for ( i = 1; A.data[i] != 0; i++ )
{
if ( head > A.data[i] ) head = A.data[i];
if ( end < A.data[i] ) end = A.data[i];
}
A.end = A.data + i - 1;
ns = 1;
a = b = c = EOD;
end++;
fclose ( fp );
}

void End ( void )
{
FILE *fp;
free ( A.data );
free ( B.data );
free ( C.data );
free ( D.data );
fp = fopen ( "output.txt", "w" );
if ( fp == NULL )
{
fclose ( fp );
exit ( __COUNTER__ );
}
if ( min == 0x7FFFFFFF )
sprintf ( tmp, "No Solution!\n" );
else
sprintf ( tmp, "%d\n%s", min, res );
fprintf ( fp, "%s", tmp );
fprintf ( stdout, "%s", tmp );
fclose ( fp );
}

void Show ( Stack a, char *s )
{
char *tmp, *pc;
char *p = (char*)a.data;
pc = tmp = (char*) malloc ( total + 1 );
while ( p <= a.end )
*pc++ = *p++;
*pc = 0;
printf ( "%s%s", tmp, s );
}

void Calc ( Data d )
{
if ( p > tmp + LEN )
{
fprintf ( stdout, "!!\n" );
return;
}
printf ( "===================================\nA: " );
Show ( A, "\tB: " );
Show ( B, "\tC: " );
Show ( C, "\tD: " );
Show ( D, "\n" );
if ( d == end )
{
if ( min > count )
{
min = count;
strcpy ( res, tmp );
return;
}
}
count++;
if ( A.end >= A.data )
a = *A.end;
else
a = EOD;
if ( B.end >= B.data )
b = *B.end;
else
b = EOD;
if ( C.end >= C.data )
c = *C.end;
else
c = EOD;
if ( a == d )
{
*++D.end = a;
A.end--;
p += sprintf ( p, "%cAD\n", a );
Calc ( d + 1 );
p -= 4;
count--;
D.end--;
A.end++;
return;
}
if ( b == d )
{
*++D.end = b;
B.end--;
p += sprintf ( p, "%cBD\n", b );
Calc ( d + 1 );
p -= 4;
count--;
D.end--;
B.end++;
return;
}
if ( c == d )
{
*++D.end = c;
C.end--;
p += sprintf ( p, "%cCD\n", c );
Calc ( d + 1 );
p -= 4;
count--;
C.end++;
D.end--;
return;
}
if ( a != EOD )
{
Data tmpA = a;
*++B.end = a;
A.end--;
p += sprintf ( p, "%cAB\n", a );
Calc ( d );
p -= 4;
B.end--;
a = tmpA;
*++C.end = a;
p += sprintf ( p, "%cAC\n", a );
Calc ( d );
p -= 4;
C.end--;
A.end++;
}
if ( b != EOD )
{
*++C.end = b;
B.end--;
p += sprintf ( p, "%cBC\n", b );
Calc ( d );
p -= 4;
C.end--;
B.end++;
}
count--;
}

void main ( void )
{
ReadData();
Calc( head );
End();
}