Homework 3 Solutions CSE 101 Summer 2017

Transcription

1 Hoework 3 Solutions CSE 0 Suer 207. Scheduling algoriths The following n = 2 jobs with given processing ties have to be scheduled on = 3 parallel and identical processors with the objective of iniizing the akespan. C j is the copletion tie of a job. A B C D E F G H I J K L (a) Draw the List-Scheduling-schedule as a Gantt-Chart. How uch is C ax and how uch is C j? (b) Draw the LPT-schedule as a Gantt-Chart. How uch is C ax and how uch is C j? (c) Draw the SPT-schedule as a Gantt-Chart. How uch is C ax and how uch is C j? (d) Find the optial and the worst list concerning the objective of iniizing the akespan. (e) Find the optial and the worst list concerning the objective of iniizing the su of the processing ties. (f) Draw McNaughton s schedule (preeptions allowed). Solution: (a) The Gantt-Chart for List-Scheduling is: C ax = ax{2,29} = 29 and C j = = 96 (b) The Gantt-Chart for LPT is: C ax = ax{2,29} = 29 and C j = = 252 (c) The Gantt-Chart for SPT is:

2 C ax = ax{2,3} = 3 and C j = = 68 (d) Lower Bound, LB = ax{2,84/3} = 28 The optial list concerning the objective of iniizing the akespan ust have a akespan of 28. One such exaple is {C,J,H,B,I,K,L,F,G,E,A,D}. The Gantt-Chart for this list using List-Scheduling is: To get the worst list concerning the objective of iniizing the akespan, reove the job with ax processing tie C(=2), then apply LS to reaining jobs such that akespan = (84-2)/3 = 24. Then add the job C to one of the achines to get the akespan to be 24+2 = 36. One such exaple is {J,H,I,K,B,G,L,F,E,A,D,C}. The Gantt-Chart for this list using List-Scheduling is: (e) SPT iniizes the su of copletion ties at 68 and LPT has the axiu at 252. (f) The Gantt-Chart for McNaughton s schedule is: 2. Upper and lower bounds for scheduling algoriths, NP-copleteness 2

3 (a) Explain why j= p j/ and p ax =ax(p k ) (for any k {,..., n}) are Lower Bounds for the akespan of any algorith solving P C ax. (b) Find Upper Bounds for the akespan of List Scheduling for P C ax. (c) Find a tight worst-case exaple for the akespan achieved by List Scheduling in coparison to the optiu akespan for = 5 processors. (d) Repeat in your own words the ost iportant ideas behind Ron Graha s proof for the worst-case behaviour of List Scheduling. (e) Prove that the decision version of P C ax is NP-coplete by reducing Partition. Solution: (a) j= p j is the total aount of processing that ust be done across all achines. Then for achines, j= pj would be the average processing that needs to be done. By properties of the average, at least one achine then ust process at least this average. Hence, C k j= pj. Also, a processor can process only one job at a tie. This eans, a job can be copleted no faster than it s given processing tie. If p ax = ax{p k }, then at least one achine ust have p ax processing load. Therefore, j= p j/ and p ax for the lower bounds for akespan of any algorith solving P C ax and clearly Cax ax { j= p j/, p ax }. (b) One upper bound is the su of all processing ties (e.g. if all jobs ran sequentially on a single achine). We can go further and lower this upper bound when we schedule the jobs according to the List Scheduling procedure: schedule the next job always on that processor that has done the least aount of work so far. Let J k denote the job that copletes last across all achines, say on achine P i. This job (by definition) was assigned when achine P i had the least load, so that: C LS ax = C k = s k + p k where s k is the aount of load on achine P i when J k was assigned to it. But this, by definition, ust have been the least load aong the achines when this happened. Therefore: So we coe to: s k j= pj,j k j= = pj p k j= = pj p k Cax LS j= = C k = s k + p k pj p k + p k and so ( ) Cax LS j= pj + p k By part (a) it follows that: ( ) ( Cax LS Cax + Cax = 2 ) C ax (c) To achieve a tight worst-case for the akespan, by List-Scheduling for = 5 processors, C ax = ( 2 5) C ax = C ax = 9 5 C ax. One exaple can be a list with 20 jobs having processing ties p j = and one job with tie p j = 5. The Gantt-Chart for this list using List-Scheduling in coparison to the optiu akespan is: 3

4 Using List-Scheduling C ax = 9, while the optiu akespan is C ax = 5. C ax = 9 5 C ax. (d) We can observe that one job J k, the one that finishes last, deterines the akespan C ax. So we have, for the akespan of List-Schedule C LS ax = p k + s k where s k is the aount of load on achine P i when J k was assigned to it. We now use relations. (i) s k, the starting tie of this job cannot be larger than the su of the processing ties of all the other jobs divided by the nuber of achines,. s k j k pj (ii) Also, the optiu akespan cannot be saller than the average processing tie or processing tie of any single job. j= pj Cax and p k Cax (see solution to part b)). (e) We are going to prove that P 2 C ax is NP-hard. (Fro this it follows that also P C ax for an arbitrary 2 ust be NP-hard. First let us define the decision versions of both probles. j= PARTITION: Given a list of n positive integers s, s 2,..., s n and a value b = sj 2, does there exist a subset J I = {,..., n} such that s j = b = j J j I/ J Reark: Partition is NP-hard in the ordinary sense, i.e. the proble cannot be optially ( solved by an algorith with polynoial tie coplexity but with an algorith of tie coplexity O (n ax s j ) k). P 2 C ax : Given n jobs with processing ties p j where j {, 2,..., n} and a nuber k, the decision version of P 2 C ax is to check if you can schedule the on achines so as to coplete by tie k. Step : P 2 C ax is in NP If the schedule of the jobs for each of the 2 achines is given, it can be verified in polynoial tie that s j 4

5 the copletion ties C,..., C n of all jobs J,..., J n are less than or equal to T. Reark: Clearly, any C k has a binary encoding which is bounded by a polynoial in the input length of the proble.) Thus, P 2 C ax belongs to NP. Note: Every decision proble solvable in polynoial tie belongs to NP. If we have such a proble P and an algorith which calculates for each input x the answer h(x) {yes, no} in a polynoial nuber of steps, then this answer h(x) ay be used as a certificate. This certificate can be verified by the algorith. Thus P is also in NP which iplies P NP. Step 2: PARTITION reduces to P 2 C ax : PARTITION P 2 C ax Note: For two decision probles P and Q, we say that P reduces to Q (denoted P Q) if there exists a polynoial-tie coputable function g that transfors inputs for P into inputs for Q such that x is a yes-input for P if and only if g(x) is a yes-input for Q. A yes-answer for a decision proble can be verified in polynoial tie (this is not the case for the no-answer). The partitioning proble is reducable to P 2 C ax :. The input of the scheduling proble can be coputed in polynoial tie given the input of the PARTITION poble: We ust polynoial transfor the input for PARTITION into an instance of P 2 C ax such that there is a solution for PARTITION if and only if there is a schedule with C ax k for a suitable value k. This is easy: We just set k = b and define the scheduling proble as follows: Consider the jobs J j with p j = s j for j =,..., n. We choose k = b as the threshold for the corresponding decision proble. 2. a. If PARTITION has a solution, then the decision version of P 2 C ax has a solution: If PARTITION has a solution, then there exists an index set J {,..., n} such that i J s i = b. In this case the schedule p i J on P and p i / J on P 2 solves the decision version of proble P 2 C ax. 2. b. If the decision version of P 2 C ax has a solution, then PARTITION has a solution: If the decision version of P 2 C ax has a solution, then the jobs with processing ties p,..., p n are scheduled on P (all p i J and P 2 (all p i / J ) such that the akespan is less than or equal to k. In this case the PARTITION j J s j = b = k = j I/ J s j solves the PARTITION proble. Since P 2 C ax is in NP, and we can reduce an NP-coplete proble to it in polynoial tie, P 2 C ax ust also be NP-coplete. 3. Tie analysis of scheduling algoriths (a) Write the Pseudocode of the List Scheduling algorith to solve P C ax. Proof the correctness and perfor a tie analysis. Does LPT has the sae tie coplexity? (b) Write the Pseudocode of McNaughton s algorith to solve P ptn C ax. Proof the correctness and perfor a tie analysis. (c) Prove that McNaughton s algorith needs never ore than n preeptions to produce an optial solution. Solution: (a) Pseudocode: INPUT: Jobs[...N];// each eleent is (jobid,duration) OUTPUT: Processor[...M];// each eleent points to an ordered list of jobids. Cax; processorid_cax; 5

6 initialise Cax = 0, processorid_cax=0; function List_scheduling(Jobs[...N],Processor[...M]) {. create MIN_HEAP for M eleents, all initialized to be (processorid,0); //two field of MIN_HEAP: processorid and aount_of_work_so_far, ordered by the latter 2. For I fro to N 3. assign (processorid, work) = the top of the MIN_HEAP); 4. reove the top of the MIN_HEAP; 5. add Jobs[I] s jobid to Processor[processorID] s list; 6. put (processorid, work+jobs[i] s duration) back to MIN_HEAP; 7. if (work+jobs[i] s duration > Cax) 8. Cax = work+jobs[i] s duration; 9. processorid_cax = processorid; 0. I++; } Correctness: () This algorith terinates, because after I iterates to N and reoving the top eleent of MIN HEAP until the last one, the function will return.(2) This algorith returns correct result. This is because the for loop processes every job. Within the scope of for loop, it puts a job to the processorid on the top of the MIN HEAP, which is guaranteed to have the sallest aount of work so far. This is exactly what List Scheduling does. Tie analysis: Line needs O(M); line 3,6 takes O(logM); other lines inside the for loop takes O(), so they are negligible. The total tie coplexity is O(M + NlogM). Using LPT will not have the sae coplexity: LPT: LPT needs to sort the Jobs array, which usually takes O(nlogn) depending on the sorting algorith. As a result, the tie coplexity becoes O(M + N(logN + logm)). (b) Pseudocode: INPUT: Jobs[...N];// each eleent is (jobid,duration) OUTPUT: Processor[...M];// each eleent points to an ordered list of (jobids, starting_tie) Cax; function McNaughton(Jobs[...N],Processor[...M]) { //copute Cax int p_ax = 0; int p_su = 0; FOR I fro to N IF Jobs[I] s duration > p_ax p_ax = Jobs[I] s duration p_su += Jobs[I] s duration 6

7 Cax = ax{ ceiling{p_su/n}, p_ax} //process each job initialize processor_pointer =, processor_size = 0; For I fro to N IF (Jobs[I] s duration < (Cax - processor_size)) add (Jobs[I] s jobid, processor_size) to Processor[processor_pointer]; processor_size += Jobs[I] s duration; I++; ELSE IF (Jobs[I] s duration == (Cax - processor_size)) add (Jobs[I] s jobid, processor_size) to Processor[processor_pointer]; processor_size = 0; processor_pointer++; I++; ELSE add (Jobs[I] s jobid, Cax - processor_size) to Processor[processor_pointer]; put (Jobs[I] s jobid, Jobs[I] s duration - (Cax - processor_size)) to I of Jobs list; processor_pointer++; processor_size = 0; } Correctness: () The algorith terinates. This is because the algorith will return after iterating all eleents in Jobs list. (2) The algoriths returns correct answer. It first coputes Cax according to the forula. Then for each job, it copares that job s duration with the vacant spaces in the processor. If there is enough space, then it just puts that job to the current processor and adds the duration to the current processor size. If there is no enough space, then it first feeds the processor as any as it can, then put the reaining as a new job back to the job list, so that it can be accessed again in the next iteration. In the next iteration, the reaining job will be put in the next processor. This is excatly what McNaughton algorith does. Tie analysis: Coputing the Cax needs O(N). Since all three cases inside the for loop only takes constant tie, we only need to find out how any iterations does the for loop have. Obviously it at least needs O(N) because there are N jobs. However, the last ELSE block ay add iterations on top of that. The nuber of execution for the last ELSE block is O(M). So the tie coplexity is O(N + M). (c): Each job interrupted at ost once. More interruptions would not yield to saller akespans. 7