基于网格的DAG任务调度算法实现（BNP-ISH、mcp、dls、etf）

        08年5月份 接的一个本科毕业设计，用了2天看懂了第一个算法（BNP-ISH），之后连续实现了其他的几个（mcp、dls、etf），第一个懂了以后后面的就好做很多，每个算法200多￥。。。。该生顺利毕业。呵呵。

        这次硬盘之灾，让我心有余悸，我想有些东西应该整理下，记录下来，对大家用处不大，对自己来说，好歹是个工作学习的见证。。。

 

 

1. /*************************************************************************************************/
2. //                                                                                      BNP-ISH算法：                                                                                                                                                                                      
3. //      1）定义任务图，本程序采用《并行分布计算中的调度算法理论与设计》P62图4.1的任务图。
4. //      2）计算每一个节点t到最终节点的最长路经的b_level值，确定优先级，b_level值越大越优先
5. //      3）从没有前向节点的节点开始执行，执行就是将节点i分配到n台机器中最优（可最早执行的）一台上，
6. //           每一台机器的执行任务速度不一样，可设置。
7. //      4）执行完成之后，再来执行。
8. //
9. //ISH算法：[ISH算法的时间复杂度是O(N*N)]
10. //      1）计算每个节点的SBL属性；
11. //      2）按SBL降序构造一个就绪任务表。
12. //      开始时，就绪任务表仅包含入口节点，然后重复如下步骤直到所有节点都调度完毕：
13. //      （1）用插入法将就绪表中的第一个节点调度到能够最早执行的处理机上；
14. //      （2）如果调度这个节点产生一个空闲段，则在就绪表中寻找尽可能多的节点，这些节点可以调度到这些空闲的时间片，
15. //           但不能更早调度到其他处理机上
16. //      （3）把已经就绪的节点插入到就绪表中
17. //
18. //
19. //
20. //
21. //
22. /*************************************************************************************************/
23. #include "stdio.h"
26. int max(int SBL[10])//该函数实现按SBL属性值的降序顺序从任务列表中取任务
27. {
28. int maxsbl=0;
29. int maxid;
30. int i;
31. for(i=1;i<10;i++)
32. {
33. if(SBL[i]>maxsbl){maxsbl=SBL[i];maxid=i;}
34. }
38. return maxid;
39. }
41. int maxitem(int a[4])//返回长度为4的数组中最大的项的下标
42. {
43.     int k=a[0]>a[1]?0:1;
44.     k= a[k]>a[2]?k:2;
45.     return a[k]>a[3]?k:3;
48. }
49. int minitem(int a[4])//返回长度为4的数组中最小项的下标【如果有最小项有相等的情况，则小下标优先】
50. {
51.     int k=a[3]<a[2]?3:2;
52.     k=a[k]<a[1]?k:1;
53.     return a[k]<a[0]?k:0;
54. }
60. void main()
61. {
62.     //定义任务图，采用二维数组表示所有节点间的关系，例如t1节点指向t2则node[1][2] = 4,而node[1][9] = 0，因为t1没有指向t9的路经
63.     //由于没有节点t0则T[0][i]全部为0。
64.     int i;
65.     int j;
66.     int node[10][10] = {0};
67.     node[1][2] = 4; 
68.     node[1][3] = 1;
69.     node[1][4] = 1;
70.     node[1][5] = 1;
71.     node[1][7] = 10;
73.     node[2][6] = 1;
74.     node[2][7] = 1;
75.   
76.     node[3][8] = 1;
78.     node[4][8] = 1;
79.     
80.     node[6][9] = 5;
81.     
82.     node[7][9] = 6;
83.     
84.     node[8][9] = 5;
85. /********************************************************************************/  
86.     //定义每一个节点的计算时间,忽略t[0]
87.     int t[10];
88.     t[1] = 2;
89.     t[2] = 3;
90.     t[3] = 3;
91.     t[4] = 4;
92.     t[5] = 5;
93.     t[6] = 4;
94.     t[7] = 4;
95.     t[8] = 4;
96.     t[9] = 1;
97. /********************************************************************************/  
98.     //定义每一个节点的前导节点,例如节点8的前导节点为节点3、4，则diaodao[8][3] = 1，diandao[8][4] = 1
99.     int qiandao[10][10] = {0};
100.     qiandao[2][1] = 1;
101.     qiandao[3][1] = 1;
102.     qiandao[4][1] = 1;
103.     qiandao[5][1] = 1;
104.     qiandao[7][1] = 1;
105.     qiandao[6][2] = 1;
106.     qiandao[7][2] = 1;
107.     qiandao[8][3] = 1;
108.     qiandao[8][4] = 1;
109.     qiandao[9][6] = 1;
110.     qiandao[9][7] = 1;
111.     qiandao[9][8] = 1;
112.         
113. /********************************************************************************/  
114.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
115.     //所以从尾节点倒序计算每一个节点的b_level值。
116.     int b_level[10] = {0};  
117.     //尾节点b_level值为0
118.     b_level[5] = 5;
119.     b_level[9] = 1; 
120.     //指示是否已经计算过b_level值
121.     int b_cal[10] = {0};
122.     b_cal[5] = 1;
123.     b_cal[9] = 1;
124.     int b_level_max, temp1, temp2, temp;
126.     //从节点t1开始计算b_level值
127.     
128.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
129.     for(int i = 1; i < 10; i++) 
130.         if(qiandao[9][i] == 1)  
131.             b_level[i] = t[9] + t[i] + node[i][9];  
133.     //计算倒数第二排节点
134.     for(int i = 1; i < 9; i++)
135.     {
136.         if(b_level[i] != 0)
137.         {
138.             for(int j = 1; j < 10; j++)
139.                 if(qiandao[i][j] == 1)
140.                 {
141.                     temp1 = t[j] + node[j][i] + b_level[i];
142.                     if(temp1 > b_level[j])
143.                         b_level[j] = temp1;
144.                 }
145.         }
146.     }   
147.     //最后计算t1节点 
148.     for(int i = 1; i < 10; i++)
149.     {
150.         if(qiandao[i][1] == 1)
151.         {
152.             temp1 = t[1] + node[1][i] + b_level[i];
153.             if(temp1 > b_level[1])
154.                 b_level[1] = temp1;
155.         }
156.         
157.     }
159.     
160. /********************************************************************************/  
163. /********************************************************************************/  
164.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
165.     //所以从尾节点倒序计算每一个节点的b_level值。
166.     int SBL[10] = {0};  
167.     //尾节点b_level值为0
168.     SBL[5] = 5;
169.     SBL[9] = 1; 
170.     //指示是否已经计算过b_level值
171.     int SBL_cal[10] = {0};
172.     SBL_cal[5] = 1;
173.     SBL_cal[9] = 1;
174.     int SBL_max, SBL_temp1, SBL_temp2, SBL_temp;
176.     //从节点t1开始计算b_level值
177.     
178.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
179.     for(int i = 1; i < 10; i++) 
180.         if(qiandao[9][i] == 1)  
181.             SBL[i] =t[9] + t[i] ;       
183.     //计算倒数第二排节点
184.     for(int i = 1; i < 9; i++)
185.     {
186.         if(SBL[i] != 0)
187.         {
188.             for(int j = 1; j < 10; j++)
189.                 if(qiandao[i][j] == 1)
190.                 {
191.                     SBL_temp1 = t[j]  + SBL[i];
192.                     if(SBL_temp1 > SBL[j])
193.                         SBL[j] = SBL_temp1;
194.                 }
195.         }
196.     }   
197.     //最后计算t1节点 
198.     for(int i = 1; i < 10; i++)
199.     {
200.         if(qiandao[i][1] == 1)
201.         {
202.             SBL_temp1 =t[1]  + SBL[i];
203.             if(SBL_temp1 > SBL[1])
204.                 SBL[1] = SBL_temp1;
205.         }
206.         
207.     }
209.     
212. //计算每个节点的前向大数
213.     int qian_max[10] = {0};
214.     for(i = 1; i < 10; i++)
215.     {
216.             temp1 = 0;
217.             for(int j = 0; j < 10; j++)
218.             {
219.                 if(node[j][i] > qian_max[i])    
220.                     qian_max[i] = node[j][i];
221.             }           
222.             
223.     }
224. /
225. //计算节点t1到其他所有节点的最大路径值
226.     int t_level[10] = {0};
227.     for(i = 1; i < 10; i++)
228.     {
229.         if(node[1][i] != 0)
230.         {
231.             t_level[i] = t[1] + node[1][i];             
232.             if(t_level[i] < temp1)
233.                 t_level[i] = temp1;
234.             for(int j = 1; j < 10; j++)
235.             {
236.                 if(node[i][j] != 0) 
237.                 {
238.                     t_level[j] = t_level[i] + node[i][j]+t[i];              
239.                     for(int k = 1; k < 10; k++)
240.                     {
241.                         if(node[j][k] != 0) 
242.                             t_level[k] = t_level[j] + node[j][k];
243.                         
244.                     }
245.                 }
246.             }   
247.         }
248.     }
250.     for(i = 1; i < 10; i++)
251.         printf("t_level[%d] = %d/n", i, t_level[i]);
252.         
253.         
254.         for(i = 1; i < 10; i++)
255.         printf("sbl[%d] = %d/n", i, SBL[i]);
258.     for(i = 1; i < 10; i++)
259.         printf("qian_max[%d] = %d/n", i, qian_max[i]);
261.     for(i = 1; i < 10; i++) 
262.     {printf("b_level[%d]: %d/n ",i, b_level[i]);}
263.     
264.     
265.     
272. ISH
273.     
274.     
275. int pe[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的开始时间，如pe[i]=x表示i任务开始执行时间为x
276. int time[4]={0,0,0,0};                     //记录机器当前时间，其值为当前分配的任务开始时间+任务的执行时间
278. int tdispatched[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的分配情况，如tdispatched[i]=x表示i任务被分配到x号机器上
281. for(i=1;i<10;i++)  //从9个任务里面，按sbl的降序取值
283. {
284. int maxid=max(SBL);
286. SBL[maxid]=0;
288. //=========================================================================================分配maxid开始
292. if(maxid==1){
293.         
294.         pe[maxid]=0;
295.         tdispatched[maxid]=0;
296.         time[0]+=t[maxid];//0号机器被用掉的时间为该任务的运行耗时
297.     
298.     
299.     
300.     }else{
301.         
302.         
303.         
305.           
308.         int early[4]={-1,-1,-1,-1};//记录一个任务如果分配到0-3号机器能够最早执行的时间
309.     
310. int a[4]={-1,-1,-1,-1};//记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）    
311.     for(int machid=0;machid<4;machid++)//往4台机器上分
312.     {
313.   int j=1;
314.   a[0]=-1;
315.   a[1]=-1;
316.   a[2]=-1;
317.   a[3]=-1;
318.   
319.   //记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）
320. //---------------------------------------------------------------------------------------------------------------trymap----
323. a[0]=time[machid];//记录当前机器的当前时间，如果任务被分配当前机器，任务必须在该时间以后执行
326. for(int i=1;i<10;i++)//遍历 找到maxid节点的前驱
327.    {
328.     if(node[i][maxid]!=0)//找到一个前驱，node[i][maxid]的值为节点maxid与节点i的通信时间
329.       {
330.          
331.           
332.           if(tdispatched[i]==machid)//如果前驱节点i与该节点maxid都被分到了同一个机器
333.            {
334.                
335.                
336.                a[j]=time[machid];//maxid任务开始时间紧接着该机器的当前时间
337.                
338.                j++;
339.             }else{//如果前驱节点与该节点没有分配到同一个机器
340.                a[j]=pe[i]+t[i]+node[i][maxid];//则maxid任务开始时间为前驱任务节点完成时间+与之通信的时间
341.               
342.                j++;
344.             }
345.     
348.       }
350.    }//for完成后，j为 maxid 节点 前驱的个数，a[0....(j-1)]为对应前驱节点产生的开始时间，其中最大的为必须满足的
351.   
352. early[machid]=a[maxitem(a)];
355. //----------------------------------------------------------------------------------------------------------------trymap---
356.     }   //得到early[0...3],里面最小的为选中的分配方案（开始时间最早）
357.         
358.     int fangan=minitem(early);//记录应该分配到哪台机器（开始时间最早）
359.     tdispatched[maxid]=fangan;//tdispatched[maxid]记录maxid任务被分配到哪台机器
360.     pe[maxid]=early[fangan];  //pe[maxid]记录maxid任务的开始时间
361.     time[fangan]=pe[maxid]+t[maxid];
362.     
363.     
364.     
365.     }
369. //==========================================================================================分配maxid结束
370. }
372. printf("【pe[i]表示i任务节点开始的执行时间】/n");
374. for(i = 1; i < 10; i++) 
375.     {printf("pe[%d]: %d/n ",i, pe[i]);}
376. printf("【i任务节点被分配到编号为tdispatched[i]的机器】/n");
377. for(i = 1; i < 10; i++) 
378.     {printf("tdispatched[%d]: %d/n ",i, tdispatched[i]);}
379. printf("【总共耗费的时间】");
381.     {printf("%d/n ",time[maxitem(time)]);}
384.     
385.     
391.  /*
392.    
393.     int   Start[9][4];
394.     int   Flag[9];
395.     int   jiuxu[9];
396.     int   temp_z[9] = {0};
397.     int   max;
398.     int   start=0;
399.     int   r[4];
400.     int   SETC[9][4];
401.     int    min;
405.     
407.     for(int j=1;j<5;j++)
408.     {r[j]=0;}
412.     int k = 1;
413.     while(k<10)
414.     {
416.     for(i=1;i<10;i++)
417.     {
418.          Flag[i]=1;
419.          jiuxu[i]=0;
420.     }
421.     
422.     for(i=1;i<10;i++)
423.     {   if(Flag[i]==1)
424.         for(int j = 1; j < 5; j++)      
425.             temp_z[i] += qiandao[i][j]; 
426.            
427.             
428.     
430.     }
432.     for(i=1;i<10;i++)
433.     {
434.         if(Flag[i]==1&&temp_z[i]==0)
435.             jiuxu[i]=1;
436.     }
438.     for(i=1;i<10;i++)
439.     {
440.         if(jiuxu[i]==1)
441.             
442.                 max=b_level[i];
443.                     start=i;
444.                 break;      
446.     }
447.     for(i=1;i<10;i++)
448.     {
449.         if(jiuxu[i]==1&&b_level[i]>max)
450.             max=b_level[i];
451.             start=i;
452.     }
453.         
454.      
455.       int m=1;
456.       min=r[1];
457.     for(j=1;j<5;j++)
458.     {      
459.             
460.             if(r[j]<min)
461.             
462.                 m=j;
463.                 
464.         }
466.     
467.     r[m]=r[m]+t[start];
469.     if(t_level[start]>r[m])
470.                 r[m]=t_level[start]+t[start];
471.             
472.                 Flag[i]=0;
473.                 
476.     k++;
479.     }
483.     int rmax=0;
485.    for(j=1;j<5;j++)
486.    {
487.        if(r[j]>rmax)
488.            rmax=r[j];
489.            
490.    }
492.    for(j=1;j<5;j++)
493.    {    printf("r[%d]： %d/n ",j,r[j]);}
494.    
497. printf("完成时间为： %d/n ",rmax);
499. */
504. }

 

1. /*************************************************************************************************/
2. //                                                                                      BNP-MCP算法：                                                                                                                                                                                      
3. //      1）定义任务图，本程序采用《并行分布计算中的调度算法理论与设计》P62图4.1的任务图。
4. //      2）计算每一个节点t到最终节点的最长路经的b_level值，确定优先级，b_level值越大越优先
5. //      3）从没有前向节点的节点开始执行，执行就是将节点i分配到n台机器中最优（可最早执行的）一台上，
6. //           每一台机器的执行任务速度不一样，可设置。
7. //      4）执行完成之后，再来执行。
8. //
9. //MCP算法：[MCP算法的时间复杂度是O(N*N*logn)]
10. //      1）计算每个节点的ALAP属性；
11. //      2）对每个节点，创建它本身的以及它的所有子结点的ALAP时间按降序构成的表；
12. //      3）将这些表按字典排序，并按这个顺序创建一个节点表，然后反复执行如下步骤，直到节点表为空时停止
13. //      （1）用插入法将将节点表的第一个节点调度到能够使该节点最早开始执行的处理机
14. //      （2）从这个节点表中去掉这个节点
15. //           
16. //      
17. //
18. //
19. //
20. //
21. //
22. /*************************************************************************************************/
23. #include "stdio.h"
26. int numofchild(int *p)
27. {
28.     int length=0;
29. for(int i=0;i<5;i++)
30. {
32.     if(p[i]!=-1){length++;}else{break;}
33. }
35. return length;
36. }
38. void BubbleSort(int *p)
39. {
40. int k=numofchild(p)-1;
41. int swap;
42. for(int i=1;i<k;i++)
43. for(int j=k;j>i;j--)
44. {   
45.     if(p[i]<p[j])
46.     {
47.         swap=p[i];
48.         p[i]=p[j];
49.         p[j]=swap;
50.     
51.     
52.     
53.     }
54. }
57. }
59. void  DictionarySort(int (*b)[5],int seq[10])//字典排序
60. {
63. int k=0;
64. int a[9][5];
65. for(int i=0;i<9;i++)
66. for(int j=0;j<5;j++)
67. a[i][j]=(*b)[k++]; 
72. int *src[9]={a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]};
77. //-----------------------------------------------------------------------------------------------------------------------------------
79.  int *p;
80.  int l,m;
81.  int x,y,swap;
82. int n=9;
83.  for (int i=0;i<n-1;i++)
84.  {
85.   l=numofchild(src[i]);
86.   for (int j=i+1;j<n;j++)
87.   {
88.      m=numofchild(src[j]); 
89.      for (x=0,y=0;(x<l)&&(y<m);x++,y++)
90.      {
91.       
92.        if ((src[i][x]>src[j][y]))
93.        {
94.         p=src[i];
95.         src[i]=src[j];
96.         src[j]=p;
98.        swap=seq[i+1];
99.        seq[i+1]=seq[j+1];
100.        seq[j+1]=swap;
102.         break;
103.        }else if(src[i][x]<src[j][y])
104.        {
105.        break;
106.        
107.        }
108.      
109.      
110.      }
112.      if(y==m)
113.      {
114.      p=src[i];
115.         src[i]=src[j];
116.         src[j]=p;
117.         swap=seq[i+1];
118.        seq[i+1]=seq[j+1];
119.        seq[j+1]=swap;
120.        break;
121.         
122.      
123.      }
124.       
128.      }
129.    
130.    
131.   }
135.   printf("将task[][]按字典排序结果/n【sort these lists in an ascending lexicographical order】/n");
139.  for (int i=0;i<n;i++)
140.  {
141.     for(int j=0;j<5;j++)
142.     {
143.         if(src[i][j]!=-1)
144.         printf("%d ",src[i][j]);}
146.     printf("/n");
147.  }
151.     //-------------------------------------------------------------------------------------------------------------------------------
155. }
160. int maxitem(int a[4])//返回长度为4的数组中最大的项的下标
161. {
162.     int k=a[0]>a[1]?0:1;
163.     k= a[k]>a[2]?k:2;
164.     return a[k]>a[3]?k:3;
167. }
168. int minitem(int a[4])//返回长度为4的数组中最小项的下标【如果有最小项有相等的情况，则小下标优先】
169. {
170.     int k=a[3]<a[2]?3:2;
171.     k=a[k]<a[1]?k:1;
172.     return a[k]<a[0]?k:0;
173. }
179. void main()
180. {
181.     //定义任务图，采用二维数组表示所有节点间的关系，例如t1节点指向t2则node[1][2] = 4,而node[1][9] = 0，因为t1没有指向t9的路经
182.     //由于没有节点t0则T[0][i]全部为0。
183.     int i;
184.     int j;
185.     int node[10][10] = {0};
186.     node[1][2] = 4; 
187.     node[1][3] = 1;
188.     node[1][4] = 1;
189.     node[1][5] = 1;
190.     node[1][7] = 10;
192.     node[2][6] = 1;
193.     node[2][7] = 1;
194.   
195.     node[3][8] = 1;
197.     node[4][8] = 1;
198.     
199.     node[6][9] = 5;
200.     
201.     node[7][9] = 6;
202.     
203.     node[8][9] = 5;
204. /********************************************************************************/  
205.     //定义每一个节点的计算时间,忽略t[0]
206.     int t[10];
207.     t[1] = 2;
208.     t[2] = 3;
209.     t[3] = 3;
210.     t[4] = 4;
211.     t[5] = 5;
212.     t[6] = 4;
213.     t[7] = 4;
214.     t[8] = 4;
215.     t[9] = 1;
216. /********************************************************************************/  
217.     //定义每一个节点的前导节点,例如节点8的前导节点为节点3、4，则diaodao[8][3] = 1，diandao[8][4] = 1
218.     int qiandao[10][10] = {0};
219.     qiandao[2][1] = 1;
220.     qiandao[3][1] = 1;
221.     qiandao[4][1] = 1;
222.     qiandao[5][1] = 1;
223.     qiandao[7][1] = 1;
224.     qiandao[6][2] = 1;
225.     qiandao[7][2] = 1;
226.     qiandao[8][3] = 1;
227.     qiandao[8][4] = 1;
228.     qiandao[9][6] = 1;
229.     qiandao[9][7] = 1;
230.     qiandao[9][8] = 1;
231.         
232. /********************************************************************************/  
233.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
234.     //所以从尾节点倒序计算每一个节点的b_level值。
235.     int b_level[10] = {0};  
236.     //尾节点b_level值为0
237.     b_level[5] = 5;
238.     b_level[9] = 1; 
239.     //指示是否已经计算过b_level值
240.     int b_cal[10] = {0};
241.     b_cal[5] = 1;
242.     b_cal[9] = 1;
243.     int b_level_max, temp1, temp2, temp;
245.     //从节点t1开始计算b_level值
246.     
247.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
248.     for(int i = 1; i < 10; i++) 
249.         if(qiandao[9][i] == 1)  
250.             b_level[i] = t[9] + t[i] + node[i][9];  
252.     //计算倒数第二排节点
253.     for(int i = 1; i < 9; i++)
254.     {
255.         if(b_level[i] != 0)
256.         {
257.             for(int j = 1; j < 10; j++)
258.                 if(qiandao[i][j] == 1)
259.                 {
260.                     temp1 = t[j] + node[j][i] + b_level[i];
261.                     if(temp1 > b_level[j])
262.                         b_level[j] = temp1;
263.                 }
264.         }
265.     }   
266.     //最后计算t1节点 
267.     for(int i = 1; i < 10; i++)
268.     {
269.         if(qiandao[i][1] == 1)
270.         {
271.             temp1 = t[1] + node[1][i] + b_level[i];
272.             if(temp1 > b_level[1])
273.                 b_level[1] = temp1;
274.         }
275.         
276.     }
278.     
279. /********************************************************************************/  
282. /********************************************************************************/  
283.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
284.     //所以从尾节点倒序计算每一个节点的b_level值。
285.     int SBL[10] = {0};  
286.     //尾节点b_level值为0
287.     SBL[5] = 5;
288.     SBL[9] = 1; 
289.     //指示是否已经计算过b_level值
290.     int SBL_cal[10] = {0};
291.     SBL_cal[5] = 1;
292.     SBL_cal[9] = 1;
293.     int SBL_max, SBL_temp1, SBL_temp2, SBL_temp;
295.     //从节点t1开始计算b_level值
296.     
297.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
298.     for(int i = 1; i < 10; i++) 
299.         if(qiandao[9][i] == 1)  
300.             SBL[i] =t[9] + t[i] ;       
302.     //计算倒数第二排节点
303.     for(int i = 1; i < 9; i++)
304.     {
305.         if(SBL[i] != 0)
306.         {
307.             for(int j = 1; j < 10; j++)
308.                 if(qiandao[i][j] == 1)
309.                 {
310.                     SBL_temp1 = t[j]  + SBL[i];
311.                     if(SBL_temp1 > SBL[j])
312.                         SBL[j] = SBL_temp1;
313.                 }
314.         }
315.     }   
316.     //最后计算t1节点 
317.     for(int i = 1; i < 10; i++)
318.     {
319.         if(qiandao[i][1] == 1)
320.         {
321.             SBL_temp1 =t[1]  + SBL[i];
322.             if(SBL_temp1 > SBL[1])
323.                 SBL[1] = SBL_temp1;
324.         }
325.         
326.     }
328.     
331. //计算每个节点的前向大数
332.     int qian_max[10] = {0};
333.     for(i = 1; i < 10; i++)
334.     {
335.             temp1 = 0;
336.             for(int j = 0; j < 10; j++)
337.             {
338.                 if(node[j][i] > qian_max[i])    
339.                     qian_max[i] = node[j][i];
340.             }           
341.             
342.     }
343. /
344. //计算节点t1到其他所有节点的最大路径值
345.     int t_level[10] = {0};
346.     for(i = 1; i < 10; i++)
347.     {
348.         if(node[1][i] != 0)
349.         {
350.             t_level[i] = t[1] + node[1][i];             
351.             if(t_level[i] < temp1)
352.                 t_level[i] = temp1;
353.             for(int j = 1; j < 10; j++)
354.             {
355.                 if(node[i][j] != 0) 
356.                 {
357.                     t_level[j] = t_level[i] + node[i][j]+t[i];              
358.                     for(int k = 1; k < 10; k++)
359.                     {
360.                         if(node[j][k] != 0) 
361.                             t_level[k] = t_level[j] + node[j][k];
362.                         
363.                     }
364.                 }
365.             }   
366.         }
367.     }
369.     for(i = 1; i < 10; i++)
370.         printf("t_level[%d] = %d/n", i, t_level[i]);
371.         
372.         
373.         for(i = 1; i < 10; i++)
374.         printf("sbl[%d] = %d/n", i, SBL[i]);
377.     for(i = 1; i < 10; i++)
378.         printf("qian_max[%d] = %d/n", i, qian_max[i]);
380.     for(i = 1; i < 10; i++) 
381.     {printf("b_level[%d]: %d/n ",i, b_level[i]);}
382.     
383.     
384.     
389. //--这个部分为MCP算法的核心，得出就绪列表【开始】--------------------------------------------------------------------------------------------------------------------
390. //（1）计算每个节点的ALAP时间
391. //（2）对每个节点，创建它本身的以及它的所有子结点的ALAP时间按降序构成的表
392. //（3）将这些表按字典排序，并按这个顺序创建一个节点表
393.     int alap[10]={-1};//-1表示未赋值时的默认无效值【因为ALAP值不会是负数】
394.     for(i=1;i<10;i++)
395.     {
396.     alap[i]=b_level[1]-b_level[i];//各个节点的ALAP值=关键路径长度-该节点的b_level值
397.     }
400. for(i = 1; i < 10; i++) 
401.     {printf("alap[%d]: %d/n ",i, alap[i]);}
402. //---section1[start]-----------------------------------------------------------------------------------------------------------
403.     int task[9][5];
404.     for(int i=0;i<9;i++)
405.         for(int j=0;j<5;j++)
406.             task[i][j]=-1;//task[][]中赋初值为-1，表示无效值（因为ALAP值不会是负数）
408.    for(int i=1;i<10;i++)//找每个节点的子结点
409.    {
410.       int k=1;
411.        task[i-1][0]=alap[i];//对每个节点，创建它本身的以及它的所有子结点的ALAP时间按降序构成的表【创建本身】
412.        for(int j=1;j<10;j++)
413.       
414.           if(node[i][j]!=0)//找到一个子节点
415.           {
416.           task[i-1][k++]=alap[j];//对每个节点，创建它本身的以及它的所有子结点的ALAP时间按降序构成的表【创建所有子结点】
417.           }
418.    
419.    }
421. printf("以下是MCP算法得出的任务调度结果：/n【以节点的ALAP值以及该节点的子节点ALAP值 构造的task[][]为：】/n");
422. for (int i=0;i<9;i++)
423.  {
424.     for(int j=0;j<5;j++)
425.     {
426.         if(task[i][j]!=-1)
427.         printf("%d ",task[i][j]);}
429.     printf("/n");
430.  }
431. //section1执行完后，task[][]在该默认例子中为{{0,8,9,8,18},{8,13,12},{9,13},{8,13},{18},{13,22},{12,22},{13,22},{22}}
432. //----section1[end]------------------------------------------------------------------------------------------------------------
433. //----section2[start]------------------------------------------------------------------------------------------------------------
434. for(int i=0;i<10;i++)
435. {
436. BubbleSort(task[0]);
437. }
439. printf("【对task[][]中所有子结点的ALAP时间按降序排序后的结果：】/n");
440. for (int i=0;i<9;i++)
441.  {
442.     for(int j=0;j<5;j++)
443.     {
444.         if(task[i][j]!=-1)
445.         printf("%d ",task[i][j]);}
447.     printf("/n");
448.  }
450. //section2执行完后，task[][]在该默认例子中为{{0,18,9,8,8},{8,13,12},{9,13},{8,13},{18},{13,22},{12,22},{13,22},{22}}
451. //作用是除task[i][0]元素外，将task[i][1...]按降序排列
452. //----section2[end]------------------------------------------------------------------------------------------------------------
453. int seq[10]={0,1,2,3,4,5,6,7,8,9};
455. DictionarySort(task,seq);//将task[][]字典排序
459. //--这个部分为MCP算法的核心，得出就绪列表【结束】----------------------------------------------------------------------------------------------------------------------------------
461. ISH
462.     
463.     
464. int pe[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的开始时间，如pe[i]=x表示i任务开始执行时间为x
465. int time[4]={0,0,0,0};                     //记录机器当前时间，其值为当前分配的任务开始时间+任务的执行时间
467. int tdispatched[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的分配情况，如tdispatched[i]=x表示i任务被分配到x号机器上
469. printf("【调度顺序：】/n");
470. for(i=1;i<10;i++)  //从9个任务里面，按sbl的降序取值
472. {
473. int maxid=seq[i];
475. printf("%d-",seq[i]);
476. //=========================================================================================分配maxid开始
480. if(maxid==1){
481.         
482.         pe[maxid]=0;
483.         tdispatched[maxid]=0;
484.         time[0]+=t[maxid];//0号机器被用掉的时间为该任务的运行耗时
485.     
486.     
487.     
488.     }else{
489.         
490.         
491.         
493.           
496.         int early[4]={-1,-1,-1,-1};//记录一个任务如果分配到0-3号机器能够最早执行的时间
497.     
498. int a[4]={-1,-1,-1,-1};//记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）    
499.     for(int machid=0;machid<4;machid++)//往4台机器上分
500.     {
501.   int j=1;
502.   a[0]=-1;
503.   a[1]=-1;
504.   a[2]=-1;
505.   a[3]=-1;
506.   
507.   //记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）
508. //---------------------------------------------------------------------------------------------------------------trymap----
511. a[0]=time[machid];//记录当前机器的当前时间，如果任务被分配当前机器，任务必须在该时间以后执行
514. for(int i=1;i<10;i++)//遍历 找到maxid节点的前驱
515.    {
516.     if(node[i][maxid]!=0)//找到一个前驱，node[i][maxid]的值为节点maxid与节点i的通信时间
517.       {
518.          
519.           
520.           if(tdispatched[i]==machid)//如果前驱节点i与该节点maxid都被分到了同一个机器
521.            {
522.                
523.                
524.                a[j]=time[machid];//maxid任务开始时间紧接着该机器的当前时间
525.                
526.                j++;
527.             }else{//如果前驱节点与该节点没有分配到同一个机器
528.                a[j]=pe[i]+t[i]+node[i][maxid];//则maxid任务开始时间为前驱任务节点完成时间+与之通信的时间
529.               
530.                j++;
532.             }
533.     
536.       }
538.    }//for完成后，j为 maxid 节点 前驱的个数，a[0....(j-1)]为对应前驱节点产生的开始时间，其中最大的为必须满足的
539.   
540. early[machid]=a[maxitem(a)];
543. //----------------------------------------------------------------------------------------------------------------trymap---
544.     }   //得到early[0...3],里面最小的为选中的分配方案（开始时间最早）
545.         
546.     int fangan=minitem(early);//记录应该分配到哪台机器（开始时间最早）
547.     tdispatched[maxid]=fangan;//tdispatched[maxid]记录maxid任务被分配到哪台机器
548.     pe[maxid]=early[fangan];  //pe[maxid]记录maxid任务的开始时间
549.     time[fangan]=pe[maxid]+t[maxid];
550.     
551.     
552.     
553.     }
557. //==========================================================================================分配maxid结束
558. }
560. printf("/n【pe[i]表示i任务节点开始的执行时间】/n");
562. for(i = 1; i < 10; i++) 
563.     {printf("pe[%d]: %d/n ",i, pe[i]);}
564. printf("【i任务节点被分配到编号为tdispatched[i]的机器】/n");
565. for(i = 1; i < 10; i++) 
566.     {printf("tdispatched[%d]: %d/n ",i, tdispatched[i]);}
567. printf("【总共耗费的时间】");
569.     {printf("%d/n ",time[maxitem(time)]);}
575.     
576.     
587. }

 

 

 

 

1. /*************************************************************************************************/
2. //dls
3. /*************************************************************************************************/
4. #include "stdio.h"
7. bool isallfinished(int *p)//判断是否所有节点都已调度完毕
8. {
10. for(int i=1;i<10;i++)
11. {
13.     if(p[i]!=1){return false;}
14. }
16. return true;
17. }
20. int maxitem(int a[4])//返回长度为4的数组中最大的项的下标
21. {
22.     int k=a[0]>a[1]?0:1;
23.     k= a[k]>a[2]?k:2;
24.     return a[k]>a[3]?k:3;
27. }
28. int minitem(int a[4])//返回长度为4的数组中最小项的下标【如果有最小项有相等的情况，则小下标优先】
29. {
30.     int k=a[3]<a[2]?3:2;
31.     k=a[k]<a[1]?k:1;
32.     return a[k]<a[0]?k:0;
33. }
39. void main()
40. {
41.     //定义任务图，采用二维数组表示所有节点间的关系，例如t1节点指向t2则node[1][2] = 4,而node[1][9] = 0，因为t1没有指向t9的路经
42.     //由于没有节点t0则T[0][i]全部为0。
43.     int i;
44.     int j;
45.     int node[10][10] = {0};
46.     node[1][2] = 4; 
47.     node[1][3] = 1;
48.     node[1][4] = 1;
49.     node[1][5] = 1;
50.     node[1][7] = 10;
52.     node[2][6] = 1;
53.     node[2][7] = 1;
54.   
55.     node[3][8] = 1;
57.     node[4][8] = 1;
58.     
59.     node[6][9] = 5;
60.     
61.     node[7][9] = 6;
62.     
63.     node[8][9] = 5;
64. /********************************************************************************/  
65.     //定义每一个节点的计算时间,忽略t[0]
66.     int t[10];
67.     t[1] = 2;
68.     t[2] = 3;
69.     t[3] = 3;
70.     t[4] = 4;
71.     t[5] = 5;
72.     t[6] = 4;
73.     t[7] = 4;
74.     t[8] = 4;
75.     t[9] = 1;
76. /********************************************************************************/  
77.     //定义每一个节点的前导节点,例如节点8的前导节点为节点3、4，则diaodao[8][3] = 1，diandao[8][4] = 1
78.     int qiandao[10][10] = {0};
79.     qiandao[2][1] = 1;
80.     qiandao[3][1] = 1;
81.     qiandao[4][1] = 1;
82.     qiandao[5][1] = 1;
83.     qiandao[7][1] = 1;
84.     qiandao[6][2] = 1;
85.     qiandao[7][2] = 1;
86.     qiandao[8][3] = 1;
87.     qiandao[8][4] = 1;
88.     qiandao[9][6] = 1;
89.     qiandao[9][7] = 1;
90.     qiandao[9][8] = 1;
91.         
92. /********************************************************************************/  
93.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
94.     //所以从尾节点倒序计算每一个节点的b_level值。
95.     int b_level[10] = {0};  
96.     //尾节点b_level值为0
97.     b_level[5] = 5;
98.     b_level[9] = 1; 
99.     //指示是否已经计算过b_level值
100.     int b_cal[10] = {0};
101.     b_cal[5] = 1;
102.     b_cal[9] = 1;
103.     int b_level_max, temp1, temp2, temp;
105.     //从节点t1开始计算b_level值
106.     
107.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
108.     for(int i = 1; i < 10; i++) 
109.         if(qiandao[9][i] == 1)  
110.             b_level[i] = t[9] + t[i] + node[i][9];  
112.     //计算倒数第二排节点
113.     for(int i = 1; i < 9; i++)
114.     {
115.         if(b_level[i] != 0)
116.         {
117.             for(int j = 1; j < 10; j++)
118.                 if(qiandao[i][j] == 1)
119.                 {
120.                     temp1 = t[j] + node[j][i] + b_level[i];
121.                     if(temp1 > b_level[j])
122.                         b_level[j] = temp1;
123.                 }
124.         }
125.     }   
126.     //最后计算t1节点 
127.     for(int i = 1; i < 10; i++)
128.     {
129.         if(qiandao[i][1] == 1)
130.         {
131.             temp1 = t[1] + node[1][i] + b_level[i];
132.             if(temp1 > b_level[1])
133.                 b_level[1] = temp1;
134.         }
135.         
136.     }
138.     
139. /********************************************************************************/  
142. /********************************************************************************/  
143.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
144.     //所以从尾节点倒序计算每一个节点的b_level值。
145.     int SBL[10] = {0};  
146.     //尾节点b_level值为0
147.     SBL[5] = 5;
148.     SBL[9] = 1; 
149.     //指示是否已经计算过b_level值
150.     int SBL_cal[10] = {0};
151.     SBL_cal[5] = 1;
152.     SBL_cal[9] = 1;
153.     int SBL_max, SBL_temp1, SBL_temp2, SBL_temp;
155.     //从节点t1开始计算b_level值
156.     
157.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
158.     for(int i = 1; i < 10; i++) 
159.         if(qiandao[9][i] == 1)  
160.             SBL[i] =t[9] + t[i] ;       
162.     //计算倒数第二排节点
163.     for(int i = 1; i < 9; i++)
164.     {
165.         if(SBL[i] != 0)
166.         {
167.             for(int j = 1; j < 10; j++)
168.                 if(qiandao[i][j] == 1)
169.                 {
170.                     SBL_temp1 = t[j]  + SBL[i];
171.                     if(SBL_temp1 > SBL[j])
172.                         SBL[j] = SBL_temp1;
173.                 }
174.         }
175.     }   
176.     //最后计算t1节点 
177.     for(int i = 1; i < 10; i++)
178.     {
179.         if(qiandao[i][1] == 1)
180.         {
181.             SBL_temp1 =t[1]  + SBL[i];
182.             if(SBL_temp1 > SBL[1])
183.                 SBL[1] = SBL_temp1;
184.         }
185.         
186.     }
188.     
191. //计算每个节点的前向大数
192.     int qian_max[10] = {0};
193.     for(i = 1; i < 10; i++)
194.     {
195.             temp1 = 0;
196.             for(int j = 0; j < 10; j++)
197.             {
198.                 if(node[j][i] > qian_max[i])    
199.                     qian_max[i] = node[j][i];
200.             }           
201.             
202.     }
205. /
206. //计算节点t1到其他所有节点的最大路径值
207.     int t_level[10] = {0};
208.     for(i = 1; i < 10; i++)
209.     {
210.         if(node[1][i] != 0)
211.         {
212.             t_level[i] = t[1] + node[1][i];             
213.             if(t_level[i] < temp1)
214.                 t_level[i] = temp1;
215.             for(int j = 1; j < 10; j++)
216.             {
217.                 if(node[i][j] != 0) 
218.                 {
219.                     t_level[j] = t_level[i] + node[i][j]+t[i];              
220.                     for(int k = 1; k < 10; k++)
221.                     {
222.                         if(node[j][k] != 0) 
223.                             t_level[k] = t_level[j] + node[j][k];
224.                         
225.                     }
226.                 }
227.             }   
228.         }
229.     }
231.     for(i = 1; i < 10; i++)
232.         printf("t_level[%d] = %d/n", i, t_level[i]);
233.         
234.         
235.         for(i = 1; i < 10; i++)
236.         printf("sbl[%d] = %d/n", i, SBL[i]);
239.     for(i = 1; i < 10; i++)
240.         printf("qian_max[%d] = %d/n", i, qian_max[i]);
242.     for(i = 1; i < 10; i++) 
243.     {printf("b_level[%d]: %d/n ",i, b_level[i]);}
244.     
245.     
246. int seq[10]={0,1,4,3,5,2,8,6,7,9};
248. int pe[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的开始时间，如pe[i]=x表示i任务开始执行时间为x
249. int time[4]={0,0,0,0};                     //记录机器当前时间，其值为当前分配的任务开始时间+任务的执行时间
251. int tdispatched[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的分配情况，如tdispatched[i]=x表示i任务被分配到x号机器上
254.     int isready[10]={0,1,1,1,1,1,1,1,1,1};//ready[i]=0表示i 任务未就绪，ready[i]=1表示任务i就绪(注1：该表的初值在下面的FOR中初始化；注2：所谓就绪指任务的父节点已执行完)
255.     int isfinish[10]={0};//初始状态所有节点都未执行
257.     
258.     
259.     
260. while(!isallfinished(isfinish))//反复调度直到所有节点都执行完毕
261. {
262.     
263.     
264.     int trystarttime[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
265.     int trymap[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
266.     
267.     int early[4]={-1,-1,-1,-1};//记录一个任务如果分配到0-3号机器能够最早执行的时间
268.     int selectedid;
269.     int dl[10]={-1024,-1024,-1024,-1024,-1024,-1024,-1024,-1024,-1024,-1024};
271.     for(int i=1;i<10;i++)//更新就绪列表
272.     {
273.       
274.       bool flag=true;
275.       for(int j=1;j<10;j++)
276.       {
277.          
278.           if(node[j][i]!=0)
279.           {
280.            if(isfinish[j]==0)//只要有一个父节点未执行完成，则该节点状态为未就绪
281.            {
282.             flag=false;
283.                
284.            }
285.           }
286.        }
287.       if(flag&&(isfinish[i]==0))//当该节点所有父节点都调度，并且该节点未被调度时，该节点标记为就绪节点
288.       {
289.       isready[i]=1;
290.       }else
291.       {
292.       isready[i]=0;
293.       }
295.     }
298.     
300. for(int i=1;i<10;i++)  
302. {
306. if(isready[i]==1)
307. {
308. selectedid=i;
309. }else{continue;}
311. //=========================================================================================分配selectedid开始
315. if(selectedid==1){
316.         
317.         
318.     
319.         
321.         trymap[selectedid]=0;
322.         trystarttime[selectedid]=0;
323.     
324.     }else{
325.         
326.         
327.         
329.           
332.         
333.     
334. int a[4]={-1,-1,-1,-1};//记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）    
335.     for(int machid=0;machid<4;machid++)//往4台机器上分
336.     {
337.   int j=1;
338.   a[0]=-1;
339.   a[1]=-1;
340.   a[2]=-1;
341.   a[3]=-1;
342.   
343.   //记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）
344. //---------------------------------------------------------------------------------------------------------------trymap----
347. a[0]=time[machid];//记录当前机器的当前时间，如果任务被分配当前机器，任务必须在该时间以后执行
350. for(int i=1;i<10;i++)//遍历 找到selectedid节点的前驱
351.    {
352.     if(node[i][selectedid]!=0)//找到一个前驱，node[i][selectedid]的值为节点selectedid与节点i的通信时间
353.       {
354.          
355.           
356.           if(tdispatched[i]==machid)//如果前驱节点i与该节点selectedid都被分到了同一个机器
357.            {
358.                
359.                
360.                a[j]=time[machid];//selectedid任务开始时间紧接着该机器的当前时间
361.                
362.                j++;
363.             }else{//如果前驱节点与该节点没有分配到同一个机器
364.                a[j]=pe[i]+t[i]+node[i][selectedid];//则selectedid任务开始时间为前驱任务节点完成时间+与之通信的时间
365.               
366.                j++;
368.             }
369.     
372.       }
374.    }//for完成后，j为 selectedid 节点 前驱的个数，a[0....(j-1)]为对应前驱节点产生的开始时间，其中最大的为必须满足的
375.   
376. early[machid]=a[maxitem(a)];
379. //----------------------------------------------------------------------------------------------------------------trymap---
380.     }   //得到early[0...3],里面最小的为选中的分配方案（开始时间最早）
384.     
385.     
386.   
387.    trymap[selectedid]=minitem(early);
388.    trystarttime[selectedid]=early[minitem(early)];
389.     
390.     
391.     }//(else)
399. //==========================================================================================分配selectedid结束
400. }//(for)就绪的节点都求到了最早开始时间，记录在trystarttime[]里，trymap[]则记录了分配方案,trydl[]里记录了每个就绪节点的最大DL
403. int k1;
404. //====================================================================================================取最大DL
405. for(int i=1;i<10;i++)//求出所有就绪节点的DL值，节点DL值=节点SBL值-节点最早开始时间
406. {
407.   if(isready[i]==1)
408.     dl[i]=SBL[i]-trystarttime[i];
410. }
416.     int k=dl[9]>dl[8]?9:8;
417.     k=dl[k]>dl[7]?k:7;
418.     k=dl[k]>dl[6]?k:6;
419.     k=dl[k]>dl[5]?k:5;
420.     k=dl[k]>dl[4]?k:4;
421.     k=dl[k]>dl[3]?k:3;
422.     k=dl[k]>dl[2]?k:2;
423.     k=dl[k]>dl[1]?k:1;//取具有最大DL值的节点
425. k1=k;//k1的值为所有就绪节点中，具有最大DL节点-处理机对的编号，
426. //====================================================================================================
427. int fangan=trymap[k1];//记录应该分配到哪台机器（开始时间最早）
428.     tdispatched[k1]=fangan;//tdispatched[selectedid]记录selectedid任务被分配到哪台机器
429.     pe[k1]=trystarttime[k1];  //pe[selectedid]记录selectedid任务的开始时间
430.     time[fangan]=pe[k1]+t[k1];//该机器（fangan）执行该任务（k1）后的时间
432.     isfinish[k1]=1;//将该任务标记为已调度
441. }//while(!isallfinished(isfinish))这个循环执行到所有任务节点都被完成
443.     
444.     
446. printf("/n【pe[i]表示i任务节点开始的执行时间】/n");
448. for(i = 1; i < 10; i++) 
449.     {printf("pe[%d]: %d/n ",i, pe[i]);}
450. printf("【i任务节点被分配到编号为tdispatched[i]的机器】/n");
451. for(i = 1; i < 10; i++) 
452.     {printf("tdispatched[%d]: %d/n ",i, tdispatched[i]);}
453. printf("【总共耗费的时间】");
455.     {printf("%d/n ",time[maxitem(time)]);}
464. }

 

 

 

 

 

 

1. /*************************************************************************************************/
2. //ETF
3. /*************************************************************************************************/
4. #include "stdio.h"
7. bool isallfinished(int *p)//判断是否所有节点都已调度完毕
8. {
10. for(int i=1;i<10;i++)
11. {
13.     if(p[i]!=1){return false;}
14. }
16. return true;
17. }
20. int maxitem(int a[4])//返回长度为4的数组中最大的项的下标
21. {
22.     int k=a[0]>a[1]?0:1;
23.     k= a[k]>a[2]?k:2;
24.     return a[k]>a[3]?k:3;
27. }
28. int minitem(int a[4])//返回长度为4的数组中最小项的下标【如果有最小项有相等的情况，则小下标优先】
29. {
30.     int k=a[3]<a[2]?3:2;
31.     k=a[k]<a[1]?k:1;
32.     return a[k]<a[0]?k:0;
33. }
39. void main()
40. {
41.     //定义任务图，采用二维数组表示所有节点间的关系，例如t1节点指向t2则node[1][2] = 4,而node[1][9] = 0，因为t1没有指向t9的路经
42.     //由于没有节点t0则T[0][i]全部为0。
43.     int i;
44.     int j;
45.     int node[10][10] = {0};
46.     node[1][2] = 4; 
47.     node[1][3] = 1;
48.     node[1][4] = 1;
49.     node[1][5] = 1;
50.     node[1][7] = 10;
52.     node[2][6] = 1;
53.     node[2][7] = 1;
54.   
55.     node[3][8] = 1;
57.     node[4][8] = 1;
58.     
59.     node[6][9] = 5;
60.     
61.     node[7][9] = 6;
62.     
63.     node[8][9] = 5;
64. /********************************************************************************/  
65.     //定义每一个节点的计算时间,忽略t[0]
66.     int t[10];
67.     t[1] = 2;
68.     t[2] = 3;
69.     t[3] = 3;
70.     t[4] = 4;
71.     t[5] = 5;
72.     t[6] = 4;
73.     t[7] = 4;
74.     t[8] = 4;
75.     t[9] = 1;
76. /********************************************************************************/  
77.     //定义每一个节点的前导节点,例如节点8的前导节点为节点3、4，则diaodao[8][3] = 1，diandao[8][4] = 1
78.     int qiandao[10][10] = {0};
79.     qiandao[2][1] = 1;
80.     qiandao[3][1] = 1;
81.     qiandao[4][1] = 1;
82.     qiandao[5][1] = 1;
83.     qiandao[7][1] = 1;
84.     qiandao[6][2] = 1;
85.     qiandao[7][2] = 1;
86.     qiandao[8][3] = 1;
87.     qiandao[8][4] = 1;
88.     qiandao[9][6] = 1;
89.     qiandao[9][7] = 1;
90.     qiandao[9][8] = 1;
91.         
92. /********************************************************************************/  
93.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
94.     //所以从尾节点倒序计算每一个节点的b_level值。
95.     int b_level[10] = {0};  
96.     //尾节点b_level值为0
97.     b_level[5] = 5;
98.     b_level[9] = 1; 
99.     //指示是否已经计算过b_level值
100.     int b_cal[10] = {0};
101.     b_cal[5] = 1;
102.     b_cal[9] = 1;
103.     int b_level_max, temp1, temp2, temp;
105.     //从节点t1开始计算b_level值
106.     
107.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
108.     for(int i = 1; i < 10; i++) 
109.         if(qiandao[9][i] == 1)  
110.             b_level[i] = t[9] + t[i] + node[i][9];  
112.     //计算倒数第二排节点
113.     for(int i = 1; i < 9; i++)
114.     {
115.         if(b_level[i] != 0)
116.         {
117.             for(int j = 1; j < 10; j++)
118.                 if(qiandao[i][j] == 1)
119.                 {
120.                     temp1 = t[j] + node[j][i] + b_level[i];
121.                     if(temp1 > b_level[j])
122.                         b_level[j] = temp1;
123.                 }
124.         }
125.     }   
126.     //最后计算t1节点 
127.     for(int i = 1; i < 10; i++)
128.     {
129.         if(qiandao[i][1] == 1)
130.         {
131.             temp1 = t[1] + node[1][i] + b_level[i];
132.             if(temp1 > b_level[1])
133.                 b_level[1] = temp1;
134.         }
135.         
136.     }
138.     
139. /********************************************************************************/  
142. /********************************************************************************/  
143.     //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
144.     //所以从尾节点倒序计算每一个节点的b_level值。
145.     int SBL[10] = {0};  
146.     //尾节点b_level值为0
147.     SBL[5] = 5;
148.     SBL[9] = 1; 
149.     //指示是否已经计算过b_level值
150.     int SBL_cal[10] = {0};
151.     SBL_cal[5] = 1;
152.     SBL_cal[9] = 1;
153.     int SBL_max, SBL_temp1, SBL_temp2, SBL_temp;
155.     //从节点t1开始计算b_level值
156.     
157.     //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
158.     for(int i = 1; i < 10; i++) 
159.         if(qiandao[9][i] == 1)  
160.             SBL[i] =t[9] + t[i] ;       
162.     //计算倒数第二排节点
163.     for(int i = 1; i < 9; i++)
164.     {
165.         if(SBL[i] != 0)
166.         {
167.             for(int j = 1; j < 10; j++)
168.                 if(qiandao[i][j] == 1)
169.                 {
170.                     SBL_temp1 = t[j]  + SBL[i];
171.                     if(SBL_temp1 > SBL[j])
172.                         SBL[j] = SBL_temp1;
173.                 }
174.         }
175.     }   
176.     //最后计算t1节点 
177.     for(int i = 1; i < 10; i++)
178.     {
179.         if(qiandao[i][1] == 1)
180.         {
181.             SBL_temp1 =t[1]  + SBL[i];
182.             if(SBL_temp1 > SBL[1])
183.                 SBL[1] = SBL_temp1;
184.         }
185.         
186.     }
188.     
191. //计算每个节点的前向大数
192.     int qian_max[10] = {0};
193.     for(i = 1; i < 10; i++)
194.     {
195.             temp1 = 0;
196.             for(int j = 0; j < 10; j++)
197.             {
198.                 if(node[j][i] > qian_max[i])    
199.                     qian_max[i] = node[j][i];
200.             }           
201.             
202.     }
205. /
206. //计算节点t1到其他所有节点的最大路径值
207.     int t_level[10] = {0};
208.     for(i = 1; i < 10; i++)
209.     {
210.         if(node[1][i] != 0)
211.         {
212.             t_level[i] = t[1] + node[1][i];             
213.             if(t_level[i] < temp1)
214.                 t_level[i] = temp1;
215.             for(int j = 1; j < 10; j++)
216.             {
217.                 if(node[i][j] != 0) 
218.                 {
219.                     t_level[j] = t_level[i] + node[i][j]+t[i];              
220.                     for(int k = 1; k < 10; k++)
221.                     {
222.                         if(node[j][k] != 0) 
223.                             t_level[k] = t_level[j] + node[j][k];
224.                         
225.                     }
226.                 }
227.             }   
228.         }
229.     }
231.     for(i = 1; i < 10; i++)
232.         printf("t_level[%d] = %d/n", i, t_level[i]);
233.         
234.         
235.         for(i = 1; i < 10; i++)
236.         printf("sbl[%d] = %d/n", i, SBL[i]);
239.     for(i = 1; i < 10; i++)
240.         printf("qian_max[%d] = %d/n", i, qian_max[i]);
242.     for(i = 1; i < 10; i++) 
243.     {printf("b_level[%d]: %d/n ",i, b_level[i]);}
244.     
245.     
246. int seq[10]={0,1,4,3,5,2,8,6,7,9};
248. int pe[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的开始时间，如pe[i]=x表示i任务开始执行时间为x
249. int time[4]={0,0,0,0};                     //记录机器当前时间，其值为当前分配的任务开始时间+任务的执行时间
251. int tdispatched[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的分配情况，如tdispatched[i]=x表示i任务被分配到x号机器上
254.     int isready[10]={0,1,1,1,1,1,1,1,1,1};//ready[i]=0表示i 任务未就绪，ready[i]=1表示任务i就绪(注1：该表的初值在下面的FOR中初始化；注2：所谓就绪指任务的父节点已执行完)
255.     int isfinish[10]={0};//初始状态所有节点都未执行
257.     
258.     
259.     
260. while(!isallfinished(isfinish))//反复调度直到所有节点都执行完毕
261. {
262.     
263.     
264.     int trystarttime[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
265.     int trymap[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
266.     
267.     int early[4]={-1,-1,-1,-1};//记录一个任务如果分配到0-3号机器能够最早执行的时间
268.     int selectedid;
270.     for(int i=1;i<10;i++)//更新就绪列表
271.     {
272.       
273.       bool flag=true;
274.       for(int j=1;j<10;j++)
275.       {
276.          
277.           if(node[j][i]!=0)
278.           {
279.            if(isfinish[j]==0)//只要有一个父节点未执行完成，则该节点状态为未就绪
280.            {
281.             flag=false;
282.                
283.            }
284.           }
285.        }
286.       if(flag&&(isfinish[i]==0))//如果所有父节点都完成，并且该节点未被调度，则该节点属于就绪节点
287.       {
288.       isready[i]=1;
289.       }else
290.       {
291.       isready[i]=0;
292.       }
294.     }
297.     
299. for(int i=1;i<10;i++)  //遍历所有节点
301. {
305. if(isready[i]==1)//如果该节点属于就绪节点
306. {
307. selectedid=i;    //则对该节点进行考察
308. }else{continue;}//否则取下一个节点
310. //=========================================================================================分配selectedid开始
314. if(selectedid==1){
315.         
316.         
317.     
318.         
320.         trymap[selectedid]=0;
321.         trystarttime[selectedid]=0;
322.     
323.     }else{
324.         
325.         
326.         
328.           
331.         
332.     
333. int a[4]={-1,-1,-1,-1};//记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）    
334.     for(int machid=0;machid<4;machid++)//往4台机器上分
335.     {
336.   int j=1;
337.   a[0]=-1;
338.   a[1]=-1;
339.   a[2]=-1;
340.   a[3]=-1;
341.   
342.   //记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）
343. //---------------------------------------------------------------------------------------------------------------trymap----
346. a[0]=time[machid];//记录当前机器的当前时间，如果任务被分配当前机器，任务必须在该时间以后执行
349. for(int i=1;i<10;i++)//遍历 找到selectedid节点的前驱
350.    {
351.     if(node[i][selectedid]!=0)//找到一个前驱，node[i][selectedid]的值为节点selectedid与节点i的通信时间
352.       {
353.          
354.           
355.           if(tdispatched[i]==machid)//如果前驱节点i与该节点selectedid都被分到了同一个机器
356.            {
357.                
358.                
359.                a[j]=time[machid];//selectedid任务开始时间紧接着该机器的当前时间
360.                
361.                j++;
362.             }else{//如果前驱节点与该节点没有分配到同一个机器
363.                a[j]=pe[i]+t[i]+node[i][selectedid];//则selectedid任务开始时间为前驱任务节点完成时间+与之通信的时间
364.               
365.                j++;
367.             }
368.     
371.       }
373.    }//for完成后，j为 selectedid 节点 前驱的个数，a[0....(j-1)]为对应前驱节点产生的开始时间，其中最大的为必须满足的
374.   
375. early[machid]=a[maxitem(a)];
378. //----------------------------------------------------------------------------------------------------------------trymap---
379.     }   //得到early[0...3],里面最小的为选中的分配方案（开始时间最早）
383.     
384.     
385.   
386.    trymap[selectedid]=minitem(early);//使该节点（selectedid）有最早开始时间的机器
387.    trystarttime[selectedid]=early[minitem(early)];//该节点（selectedid）的最早开始时间
388.     
389.     
390.     }//(else)
398. //==========================================================================================分配selectedid结束
399. }//(for)就绪的节点都求到了最早开始时间，记录在trystarttime[]里，trymap[]则记录了分配方案,trydl[]里记录了每个就绪节点的最大DL
402. int k1;
403. //====================================================================================================取最早开始时间，如果时间一样 取小SBL
405. for(int i=1;i<10;i++)
406.     {
407.     if(trystarttime[i]==-1) trystarttime[i]=1024;  //非就绪节点的开始时间设为无穷大(用1024代替)
408.     
409.     }
412.     int k=trystarttime[9]<trystarttime[8]?9:8;
413.     k=trystarttime[k]<trystarttime[7]?k:7;
414.     k=trystarttime[k]<trystarttime[6]?k:6;
415.     k=trystarttime[k]<trystarttime[5]?k:5;
416.     k=trystarttime[k]<trystarttime[4]?k:4;
417.     k=trystarttime[k]<trystarttime[3]?k:3;
418.     k=trystarttime[k]<trystarttime[2]?k:2;
419.     k=trystarttime[k]<trystarttime[1]?k:1;//取所有就绪节点中，具有最早开始时间的(存在这样的情况：几个节点同时具有最早开始时间)
421.     for(int i=1;i<10;i++)//在几个节点同时具有最早开始时间的情况下，考察SBL，小SBL优先分配
422.     {
423.       if(trystarttime[k]==trystarttime[i])
424.       {
425.         if(SBL[k]<SBL[i])
426.         {
427.          k=i;
428.         }
429.       }
430.     }
432. k1=k;//k1的值为所有就绪节点中，选中准备分配的编号
433. //====================================================================================================
434. int fangan=trymap[k1];//记录应该分配到哪台机器（开始时间最早）
435.     tdispatched[k1]=fangan;//tdispatched[selectedid]记录selectedid任务被分配到哪台机器
436.     pe[k1]=trystarttime[k1];  //pe[selectedid]记录selectedid任务的开始时间
437.     time[fangan]=pe[k1]+t[k1];//该机器（fangan）运行该任务（k1）后的时间
439.     isfinish[k1]=1;//将该节点标记为已完成
448. }//while(!isallfinished(isfinish))这个循环执行到所有任务节点都被完成
450.     
451.     
453. printf("/n【pe[i]表示i任务节点开始的执行时间】/n");
455. for(i = 1; i < 10; i++) 
456.     {printf("pe[%d]: %d/n ",i, pe[i]);}
457. printf("【i任务节点被分配到编号为tdispatched[i]的机器】/n");
458. for(i = 1; i < 10; i++) 
459.     {printf("tdispatched[%d]: %d/n ",i, tdispatched[i]);}
460. printf("【总共耗费的时间】");
462.     {printf("%d/n ",time[maxitem(time)]);}
471. }