UNIVERSITY OF 
 
 ILLINOIS LIBRARY 
 
 AT URBANA-CHAMPAIGN 
 
JlAA'ff Report No. UlUCDCS-R-7^-678 
 
 /7U^C4i 
 
 IAN 
 
 61< 
 
 COST MINIMIZATION IN COMPUTER SYSTEMS SUBJECT 
 TO MULTIPLE MEMORY CONSTRAINTS 
 
 by 
 
 Michael Austin Jamerson 
 
 October I97U 
 
 The Library of the 
 
 JAN 3- 1975 
 
 ■ 
 
Digitized by the Internet Archive 
 in 2013 
 
 http://archive.org/details/costminimization678jame 
 
Report No. UIUCDCS-R-7i+-678 
 
 COST MINIMIZATION IN COMPUTER SYSTEMS SUBJECT 
 TO MULTIPLE MEMORY CONSTRAINTS 
 
 by 
 
 Michael Austin Jamerson 
 
 Department of Computer Science 
 University of Illinois at Urbana-Champaign 
 Urbana, Illinois 61801 
 
 This work was submitted in partial fulfillment of the requirements for 
 the degree of Master of Science in Computer Science in the Graduate 
 College of the University of Illinois at Urbana-Champaign, 197^* 
 
Ill 
 
 ACKNOWLEDGMENTS 
 
 I would like to express my sincere appreciation to Western Electric 
 and their Engineering and Science Fellowship Program whose financial assistance 
 helped make this paper possible. In addition, I would like to thank 
 Dr. Edward K. Bowdon whose guidance and advice in preparation of this paper 
 was invaluable. Lastly, deepest thanks to my loving wife who provided con- 
 stant support and encouragement throughout the preparation of this paper. 
 
iv 
 
 TABLE OF CONTENTS 
 
 Page 
 
 1. INTRODUCTION 1 
 
 2. INTERACTION EFFECTS IN A MULT I PROGRAMMED SYSTEM 4 
 
 2.1 Memory Resources 4 
 
 2.2 Job Interaction 5 
 
 3. SINGLE RESOURCE SYSTEMS 17 
 
 3.1 Scheduling Contiguous Memory Resources 19 
 
 3.2 Scheduling Fragmented Memory Resources 32 
 
 4. MULTIPLE MEMORY CONSTRAINTS 39 
 
 5. CONCLUSION -- 48 
 
 LIST OF REFERENCES 50 
 
1. INTRODUCTION 
 
 Every computer center is faced with the problem of providing service to 
 its customers at a cost and speed which is acceptable to the customer and at 
 the same time satisfies management goals. One important aspect of the cost 
 of a computing center is the amount and types of memory which are available. 
 Generally, the types of memory devices are dictated by the user community. 
 The amounts of the memories, on the other hand, are limited if not by cost, 
 then by physical limitations such as floor space or hardware design. When- 
 ever a resource is limited to a degree that requires considerations of the size 
 of the resource, then that resource is constrained. It is the goal of this 
 paper to present scheduling techniques which minimize the amounts of idle 
 resources, while providing nearly optimal flowtimes. 
 
 The systems which we will consider will be those with a single centra] 
 processing unit (CPU) having the capability of concurrently processing two or 
 more jobs. We will use the term multiprogramming to apply to these systems. 
 The essential point in a multiprogramming system is that although more than one 
 job may be present in main memory (CORE) only a single job is being processed 
 at any given instant. The flowtime or run time of a job is derived from three 
 elements: 1) active time, 2) passive time, and 3) wait time. Active time is 
 the time in which CPU processing takes place. The term passive time will be 
 used to denote the time consumed by events which are external to the CPU such 
 as input-output processing. Time which is neither active nor passive will be 
 called wait time. Wait time includes but is not limited to time spent in queues 
 prior to the start of processing and time spent waiting for the CPU when the 
 CPU is processing another job. 
 
 * 
 
 Flowtime is defined as the amount of time a job spends in the system. 
 
Scheduling techniques which have been previously discussed in the 
 literature are generally concerned with the problem of minimizing some 
 measure such as maximum flowtime, average flowtime, or maximum lateness [l]. 
 Results for systems where a single server processes a single request at a time 
 also have been extensively examined. Browne, Lan, and Baskett [2] discuss the 
 results of various scheduling strategies such as f irst-come-first-serve (FCFS) 
 and shortest processing time (SPT) in a multiprogrammed environment. In all 
 of the above strategies, jobs are selected for processing on the basis of 
 their arrival or required processing time. One technique considered by 
 Browne, Lan and Baskett [2J, the smallest memory first (SMF) algorithm, is 
 concerned with memory availabilities, but not with the best use of those 
 resources . 
 
 Some scheduling systems currently in use are based on a scheme for evaluat- 
 ing the resources requested by a job. In these systems the resource requests 
 such as amount of CORE and CPU processing time are used as the independent 
 variables of a function. The result of evaluating this function is then used 
 to assign a priority to the job. Other systems rely on a user defined priority 
 and operate under a FCFS selection discipline within the individual priority 
 queues. In all of the techniques which have been discussed the resources are 
 checked to insure that enough of the resource is available to satisfy the 
 requirements of a given job. However, no attempt is made to select jobs which 
 best utilize the available resources. 
 
 Denning [3] presents one approach to the problem of efficient utilization 
 of the available resources. He presents the concept of a "working set" and 
 suggests that jobs be run according to their ability to restore system balance 
 
as opposed to using some other priority criteria. This approach merits 
 further discussion and will be examined in Chapter 3. 
 
 A selection technique which attempts to maximize the utilization of the 
 available resources by the selection of one or more jobs for execution will be 
 called a best fit selection technique (BFST) . A BFST may be used in conjunc- 
 tion with some other technique such as SPT or FCFS in order to minimize some 
 other measure of the system, but the primary goal of a BFST will always be the 
 minimization of the amount of idle resources. 
 
 It has been shown that when arrival times are exactly known, that 
 inserted idle time may improve the resource utilization of a system [lj. The 
 concept of inserted idle time may be incorporated into a BFST. We will not 
 consider cases in which the arrival times are known and therefore we will not 
 be concerned with inserted idle time. 
 
 In Chapter 2 we will define the various types of resources and develop 
 a methodology for determining the effect of job interaction in a multiprogram- 
 ming system on a given job's run time. These results are then used in Chapter 
 3 to develop a BFST for the case of a system with a single constrained memory 
 resource. Chapter 4 will investigate the application of a BFST to a generalized 
 system with multiple constrained memory resources. Finally we conclude with 
 a review of the results of Chapters 3 and 4 and then attempt to identify the 
 future research which will be required. 
 
2. INTERACTION EFFECTS IN A MULTI PROGRAMMED SYSTEM 
 
 2.1 Memory Resources 
 
 Every computer center is faced with the problem of meeting its customers' 
 demands for service. These service demands consist of two parts: (1) requests 
 for portions of the available memory resources and (2) a period of time during 
 which those resources will be used. The responsibility of meeting these 
 demands in a time frame which is acceptable to the users rests with the 
 computing center management. Management must, on the other hand, attempt to 
 balance the use of these resources and minimize the amount of idle resource. 
 We now turn our attention to the subject of what those resources are and how 
 multiple users interact in the pursuit of the use of those resources. 
 
 We will consider each computer center to consist of a single CPU which is 
 capable of multiprogramming and a number of constrained memory resources. In 
 considering the multiprogramming capability of the CPU, we will assume that 
 neither the hardware nor its controlling operating system will pose a limit on 
 the number of jobs which may run concurrently. 
 
 The constrained memory resources may be divided into two classes: 1) con- 
 tiguous and 2) fragmented. A contiguous memory resource (CMR) is a resource 
 in which a contiguous portion of the resource must be used to satisfy a resource 
 request. The prime example of a contiguous memory resource is the CORE of the 
 CPU. Here the user's request must be filled by s single contiguous portion of 
 CORE. There are cases in which CORE is not treated as a contiguous resource, 
 but those cases will not be considered here. Fragmented memory resources (FMR) 
 are those resources in which requests for the resources need not be filled by 
 a contiguous assignement but rather by the assignment of individual resource 
 units. An example of an FMR is the magnetic tape drive pool. In this case, a 
 
user's request for a number of tape drives is satisfied by selecting as many 
 of the unassigned drives as are required. The question of whether the drives 
 are logically or even physically contiguous is not raised. 
 
 The available size of any memory resource may be reduced from the actual 
 size. These reductions may be static or dynamic in nature. We will call those 
 reductions which occur because of various day-to-day requirements of the 
 computing center, static reductions. Examples of static reductions include the 
 decrease in available CORE caused by the presence of the operating system and 
 other real time activities or the reduction in available tape drives resulting 
 from the allocation of one or more drives for the function of logging system 
 activities. Static reductions then are predictable and can be taken into con- 
 sideration. Dynamic reductions, on the other hand, are unpredictable in terms 
 of occurrence and size. Particular examples of dynamic reductions are equipment 
 failures or the dedication of a portion of CORE to insure the completion of 
 some critical job. 
 
 Thus we see that, at any given instant, the amounts of the memory resources 
 may be less than originally planned. For convenience we will view the static 
 reductions of each resource as though those portions of the resources were 
 never available. Dynamic reductions will be treated as service requests of an 
 indefinite length which exactly equal the size of the particular dynamic reduc- 
 tion. We will denote the available amount of a resource i, given by the 
 difference of the original size of the resource and the sum of the static 
 reductions for that resource, as R. . 
 
 2.2 Job Interaction 
 
 Each user job which enters the computing center and begins processing 
 interacts with other jobs which are in the center. This interaction results in 
 
a prolongation of the flowtime for all of the jobs which are involved. In 
 this section we will develop analytical tools which will provide information 
 concerning this prolongation. 
 
 The systems with which we will be concerned are single processor systems. 
 A basic element in our concept of a single processor is that it may only 
 process a single task at a time. Thus, even in a multiprogramming environment 
 in which many jobs may be in execution and all are competing for the CPU, only 
 one job is using the CPU at any given instant. 
 
 Each job which enters the computing center will be characterized by a set 
 of parameters which indicate the resources required by that job and the process- 
 ing characteristics of that job. These parameters are: 
 
 1) a. - the amount of CPU processing time required by job i. 
 
 2) p. - the amount of passive time which job i requires. 
 
 3) R. . - the amount of resource j which is required by job i. 
 
 When job i is the only job which is in execution, then the execution time, 
 e. , for job i is the sum of the active and passive times 
 
 e. = a. + p. . (1) 
 
 ill 
 
 In dealing with the jobs which are characterized by the n+2 tuple (a.,p.,R #1 , 
 
 R._,'* , ,R. ) we assume that: 
 iz' 'in 
 
 1) the passive time, p., is evenly distributed over the execution time, 
 
 ta. 
 or that in any time interval, t, the amount of active time is and the 
 
 tp t e i 
 
 amount of passive time is . 
 
 e. 
 l 
 
 2) the amount, R. ., of any resource which is requested by job i is less 
 than the available amount, R., of resource j. 
 
When two or more jobs are concurrently executing we observe a phenomenura 
 which will be called overlap. Overlap is a result of the use of the CPU to 
 process a job when some other job is in a period of passive time. The effect 
 of overlap is a reduction in the overall execution time. From this we see that 
 overlap is a measure of how well the active and passive periods of jobs mesh. 
 Using these observations we will define the overlap factor, <3, as the ratio of 
 the amount of processing that occurs in a given period of time. In dealing 
 with overlap factors we will make the following assumptions: 
 
 1) the amount of overlap in a given period is constant, < & < 1 , when 
 two or more jobs are processing and unity when only one job is processing. 
 
 2) processing is equitably rationed to each job which is being processed. 
 
 The amount of overlap is dependent on factors which are intrinsic to the com- 
 puter center and is to be determined experimentally. In real life the amount 
 of overlap is dependent on the total number of jobs. Beginning at some low 
 value, <3 increases to some optimum, and then decreases as more jobs compete 
 for the resources of the CPU. 
 
 As stated the execution time, e., of a job is dependent on both the job 
 and the other jobs in the system. We now develop the techniques for deter- 
 mining the relationship of the execution time to the state of the system. Let 
 C^(n) be the overlap factor for a given system with n jobs. Let j. be a job 
 
 with active time, a., and passive time, p.. The execution time for i. is 
 
 i l l 
 
 e. >a. + p., where the equality holds if j. is the only job which is processed. 
 
 We assume that the available processor time is rationed in an equitable 
 fashion to every job which is being concurrently processed. This rationing is 
 designed to prevent the disproportionate assignment of processing time that 
 
8 
 
 could occur if a job with a Large amount of active time and Little or no 
 
 passive time were aLLowed to execute untii it relinquished control of the 
 
 CPU. Thus we can guarantee that each of the n jobs which are processing will 
 
 be provided with at least — of each available processor minute. Under our 
 
 n r 
 
 assumption that the passive time is evenly distributed over the execution time, 
 
 a . 
 
 we see that no job may use more than — of a processor minute. 
 
 i a 
 
 If a iob cannot utilize its entire share of the processor, — < — , 
 
 e. n ' 
 
 1 
 
 the unused time will be distributed evenly to the other jobs which are execut- 
 ing. Thus, each job is given an initial allocation of t. < 1 minutes of the 
 
 1 a i 
 available processor time, where t. = min(-0-. — ). The unused time, U , is 
 r ) x n ' e. ' T 
 
 l 
 
 given by the expression 
 
 = Y k> - min(r<5, — ) 
 Z_j n n e. 
 
 (2) 
 
 n 
 
 a 
 
 i . i 
 
 U T 
 
 i-1 
 
 -5>i 
 
 = o 
 
 i=l 
 
 The unused time, U , may now be allocated to those n' < n jobs having 
 
 a . 
 
 t. < — . The new allocations are then 
 i e. 
 
 l 
 
 U a. 
 
 t. = min(t. + -7 , — ) . (3) 
 
 l i n' e. 
 
 l 
 
 Again the unused time is colllected and distributed. This process continues 
 
 a. 
 
 until each iob has been allocated t. = — units of time or U^ = 0. 
 
 l e . T 
 
 l 
 
 The above discussion indicates the technique used to determine the amount 
 of processing which is allocated to each concurrently running job. Using this 
 technique under the assumption that the passive time is evenly distributed with 
 respect to the processing time we may new calculate the real time requirements 
 
for processing a set of jobs. The following example is provided to illus- 
 trate these techniques. 
 
 Let us start with four jobs which are to be processed by a system with 
 an overlap factor O = 0.9. To avoid confusion we will not be concerned with 
 resource constraints on requirements at this time. The parameters of the 
 four jobs are shown in Table 2.1. In this illustration, we assume that jobs 
 1, 2, and 3 are all started at the same time, T = 0, and that job 4 will begin 
 execution when one of the first three jobs completes. 
 
 
 
 Table 2.1 
 
 
 
 Job 
 
 
 
 passive time, 
 
 
 a. 
 
 l 
 
 active time, 
 
 a . 
 
 l 
 
 y i 
 
 a.+p. 
 
 L 1 
 
 1 
 
 1 
 
 
 
 
 
 1 
 
 2 
 
 2 
 
 
 2 
 
 
 .5 
 
 3 
 
 1 
 
 
 3 
 
 
 .25 
 
 4 
 
 1 
 
 
 2 
 
 
 .33 
 
 Using the information in Table 2.1 and the preceding formulas we will now 
 determine the processor allocations. Table 2.2 shows the results of the cal- 
 culations and illustrates the effect of multiprogramming. In the Gantt chart 
 of Figure 2 . 1 we have graphically shown the progress of each job. From the 
 above description we see that the CPU allocation factor, T, may change when- 
 ever a job begins or finishes processing. It is these points in time which 
 
 must be determined. Barring any changes in the system a given job will require 
 
 a. 
 
 — to finish. Thus we may determine the completion time of the first job by 
 
 1 a l 
 computing — = 3.077 to be the smallest and so job 1 is the first to finish. 
 
 Using this value we may now determine how much processing the other jobs 
 
 a l 
 received by calculating T. (— — ). We see these values tabulated in column 7 of 
 
Table 2.2. A sample Job Stream 
 
 10 
 
 Time 
 
 Job 
 
 n 
 
 a . 
 l 
 
 e . 
 
 l 
 
 CPU 
 allocation (t) 
 
 time remaining 
 
 time processed 
 
 
 
 1 
 2 
 3 
 
 .3 
 .3 
 .3 
 
 1.0 
 0.5 
 0.25 
 
 0.325 
 0.325 
 0.25 
 
 1.0 
 2.0 
 1.0 
 
 
 
 
 
 3.0769 
 
 1 
 2 
 3 
 
 .3 
 .3 
 .3 
 
 1.0 
 0.5 
 0.25 
 
 0.325 
 0.325 
 0.25 
 
 
 1.0 
 0.2308 
 
 1.0 
 1.0 
 0.7692 
 
 3.0769 
 
 2 
 3 
 
 4 
 
 .3 
 .3 
 .3 
 
 0.5 
 
 0.25 
 
 0.33 
 
 0.325 
 
 0.25 
 
 0.325 
 
 1.0 
 0.2308 
 
 1.0 
 
 1.0 
 0.7692 
 
 
 4.0000 
 
 2 
 3 
 
 4 
 
 .3 
 .3 
 .3 
 
 0.5 
 
 0.25 
 
 0.33 
 
 0.325 
 
 0.25 
 
 0.325 
 
 0.7000 
 
 
 0.7000 
 
 1.3000 
 
 1.0 
 0.3000 
 
 4.0000 
 
 2 
 4 
 
 .45 
 .45 
 
 0.5 
 0.33 
 
 0.5 
 0.33 
 
 0.7000 
 0.7000 
 
 1.3000 
 
 0.300 
 
 5.4000 
 
 2 
 4 
 
 .45 
 .45 
 
 0.5 
 0.33 
 
 0.5 
 0.33 
 
 
 0.2333 
 
 2.0 
 0.7667 
 
 5.4000 
 
 4 
 
 1.0 
 
 0.33 
 
 0.33 
 
 0.2333 
 
 0.7667 
 
 6.1 
 
 4 
 
 1.0 
 
 0.33 
 
 0.33 
 
 
 
 1.0 ; 
 
11 
 
 -3- 
 
 CM 
 
 
 -LTN 
 
 PM 
 
 C\J 
 
 -VO 
 
 c 
 
 •H 
 J3 
 
 0) 
 
 S 
 
 •H 
 
 E-i 
 
 d) 
 ft 
 
 H 
 W 
 
 C\J 
 
 CM 
 
 ■s 
 
 EH 
 
 C 
 
 •H 
 
 w 
 o 
 
 u 
 o 
 
 0) 
 
 <D 
 ,d 
 o 
 
 CO 
 
 <D 
 C 
 O 
 
 <H 
 O 
 
 -P 
 
 .c 
 
 o 
 
 -p 
 -p 
 C 
 n) 
 O 
 
 O Pn p 
 
 < H H O O cS-p-HOC 
 
12 
 
 Table 2.2. To locate the next completion point, we repeat the procedure of 
 
 a. 
 finding the smallest — , keeping in mind that each a. will now have a new 
 
 i 
 value equal to the original value minus the amount of processing accomplished. 
 
 Thus we see that at each termination we must recalculate the CPU allocation 
 
 factor, T , for each job and subsequently determine the next termination 
 
 a. 
 point given by min( — ). Having carried out this procedure we find the time 
 
 V i ^ 
 taken to complete the four jobs is approximately 6.1 minutes. 
 
 A question that we might ask at this point is what is the minimum time to 
 
 complete the four jobs. By summing the active time requirements shown in 
 
 Table 2.1, we find that five minutes of processor time are needed. Since the 
 
 CPU may only process one job at a time this is the minimum time needed for 
 
 the four jobs. But due to the constraint that the overlap factor is 0.9 only 
 
 0.9 of every minute will be used to process the jobs. The minimum flowtime, 
 
 F . , now becomes the sum of the active times for each job divided by the 
 min 
 
 overlap factor or 
 
 n 
 
 = y a, 10 . (h) 
 
 €. ■ ■ I 
 
 1 = 1 
 
 For this case, F . = 5.55. This minimum only holds true when the sum of the 
 mm 
 
 CPU allocation factor is equal to the overlap factor at every instant during 
 the run. This condition, Z t. = O can be satisfied. This is satisfied by 
 processing jobs 2,3,4 together and then starting job 1 when job 4 finishes. 
 This is shown in the Gantt chart of Figure 2.2. Another measure of interest 
 is the average flowtime defined: 
 
 F 
 min /, l" 
 
 F = - ) a.+p.+0J. . (5) 
 
 i=l 
 
13 
 
 O PL, O 
 
 <HHOOcd-p-HOfl 
 
14 
 
 As shown in Conway, Markwell, and Miller [l] schedules which result in 
 
 minimum flowtime, F . , may not result in minimum average flowtime, F . For 
 
 min m in 
 
 the set of jobs shown in Table 2.1, F . and F . are both satisfied by the 
 
 min min ' 
 
 schedule given in Figure 2.2. Table 2.3 lists a set of jobs where the 
 
 schedule which results in F . does not result in F . These two schedules 
 
 min min 
 
 are presented in the Gantt charts of Figures 2.3 and 2.4. 
 
 
 
 
 Job 
 
 Active Time 
 
 • i — ■ 
 Passive Time 
 
 I 1 
 
 1 
 
 1.5 
 
 2 
 
 1 
 
 2.33 
 
 3 
 
 2 
 
 
 
 4 
 
 2 
 
 1.33 
 
 5 
 
 2 
 
 4 
 
 Table 2.3. A set of jobs where schedule for F . is 
 
 not the same as F . schedule, 
 min 
 
 We have seen in this chapter that the memory resources of a computing 
 center may be divided into two classes, contiguous and fragmented. In the 
 second section we examined the question of how job interaction affects the 
 execution time of other concurrently running jobs. Armed with these tools we 
 are now prepared to attack the problem of scheduling jobs in a system with 
 constrained memory resources. 
 
15 
 
 CO 
 
 C\J 
 
 CD 
 H 
 
 ■3 
 
 EH 
 
 en 
 O 
 
 1-3 
 
 o 
 
 a; 
 
 o 
 w 
 
 <v 
 
 6 
 
 •H 
 
 o 
 
 CD 
 M 
 cd 
 
 t> 
 
 a} 
 
 CvJ 
 H 
 
 O Ph D 
 
 <HHOCJCtS-pv-IOe! 
 
16 
 
 
 P-, 
 
 co 
 
 fe 
 
 P-. 
 
 Ph 
 
 CM 
 
 Ph 
 
 CO 
 
 
 CO 
 
 CO 
 
 
 • 
 
 • 
 
 
 CM 
 
 CO 
 
 
 H 
 
 ,£> 
 
 En 
 
 a 
 
 •H 
 
 w 
 
 ,£> 
 
 O 
 
 •i-3 
 
 VO 
 
 
 U 
 
 vr> 
 
 
 a 
 
 • 
 
 
 «H 
 
 VO 
 
 
 (U 
 
 
 ^-^ 
 
 3 
 
 
 in 
 
 >cJ 
 
 
 0) 
 
 <u 
 
 
 -p 
 
 ,C 
 
 
 3 
 
 o 
 
 
 c 
 
 M 
 
 
 •H 
 
 
 
 £ 
 
 0) 
 
 
 
 S 
 
 
 
 
 •H 
 
 
 S 
 
 •H 
 
 s 
 
 
 EH 
 
 O 
 H 
 
 
 <ti 
 
 q-i 
 
 
 <D 
 
 
 
 w 
 
 £ 
 
 
 ft 
 
 3 
 
 
 of 
 
 S 
 
 
 H 
 
 ■H 
 
 
 H 
 
 X 
 
 CO 
 
 
 ccl 
 
 CO 
 
 
 6 
 
 CO 
 
 
 6 
 ■H 
 
 G 
 •H 
 
 6 
 
 o 
 
 On 
 
 O pj CD 
 
 e 
 
 CM 
 
 CM 
 
 H 
 P5 
 
 g 
 H 
 
 <jHHOCJa5-P'HOG 
 
17 
 
 3. SINGLE RESOURCE SYSTEMS 
 
 We now turn our attention to the development of a best fit scheduling 
 technique for a system with a single constrained resource. Methods and results 
 will be developed for both contiguous and fragmented resources. In our dis- 
 cussions we will use the following notation: 
 
 1) R - size of the constrained resource after static reductions 
 
 2) - the system overlap factor 
 
 3) T . (t) - the sum of the CPU allocation factor for job i at time t 
 
 4) f(t) " the sum of the CPU allocation factors at time t 
 
 5) (a.,p.,r.) - the description of a job i; where a. is the active 
 
 time, p. is the passive time, and r. is the amount of resource R which is 
 r i r l 
 
 requested . 
 
 Additionally we will make the following assumptions: 
 
 1) All jobs which are to be scheduled in an interval (tQ, tt.) are present 
 
 at t . Jobs which arrive after t will not be scheduled until t, . 
 o o 1 
 
 2) No job may request the entire resource, i.e. for all i, r. < R. 
 
 3) Dynamic reductions appear as schedulable jobs with the description 
 (0, p, ,r.) where p, is the length of time of the dynamic reduction and r, is 
 the size of the dynamic reduction. 
 
 4) The system overlap factor, O, is a constant, O < I, for two or more 
 jobs in execution, with equality holding when there is only 1 job in the system. 
 Note: If a job is processing when we choose to begin scheduling we will treat 
 that job as a new job with new parameters. Although the resource requirement 
 will remain unchanged, the active and passive times will be modified to reflect 
 the fact that some processing has already occurred. If at time t„ we investi- 
 gate the system we will find that the amount of active time used by job i in 
 
18 
 
 '2 
 the interval (t ,t 2 ) is given by: j T dt. Using this (or perhaps by 
 
 simply keeping an internal record of the active time used by the job), we may 
 
 calculate the new values of a. and p., as 
 
 L 1 
 
 C 2 
 
 a.' = a. - t dt 
 i i J t 
 
 1 
 Pi 
 
 i 
 
 The description of job i then becomes (a!,p!,r.) and we treat it as a new job 
 for the purpose of scheduling the next interval. Having set the stage we now 
 proceed to develop a best fit scheduling technique for a system with a single 
 constrained resource. 
 
 We recall from chapter 2 that the minimum flowtime, F . , for a set of 
 
 mm 
 
 schedulable jobs will be achieved, if T(t) = (5 for all t in the execution 
 
 interval. Intuitively, this makes sense since it simply says that the best 
 
 that we can do is to use every available instant of processor time. Our 
 
 ultimate goal is then to schedule a set of iobs in the interval (t , t..) such 
 
 o 1 
 
 that 
 
 and 
 
 x(t) =0 t e (t o ,t x ) (1) 
 
 y r = R . (2) 
 
 & c 
 
 The desirability of this goal is obvious, since it would imply that the CPU 
 
 was used to its fullest extent while no resource went idle. The attainability 
 
 is at best elusive, and thus we will replace (1) and (2) with the minimization 
 constraints 
 
 min(0-T(t)) t e (t^t^ (3) 
 
19 
 
 min(R - 2^ r ± ) t € (t^t^) . (4) 
 
 ieE 
 S t 
 
 3.1 Scheduling Contiguous Memory Resources 
 
 The scheduling problems encountered in dealing with contiguous memory 
 resources are somewhat analogous to those presented by the cutting stock 
 problem [ 5 J • A. contiguous memory resource, as defined in chapter 2, is a 
 memory resource which must be assigned in a single contiguous portion. This 
 is similar to the case of a customer who orders a piece of sheet metal from a 
 foundry. Just as the sheet metal customer would be unable to use several 
 small pieces in place of the one large piece that was originally ordered, the 
 user of a contiguous memory resource is unable to use small pieces of non- 
 contiguous memory to satisfy his request. 
 
 Let us assume for the moment that both the foundry operator and the comput- 
 ing center are faced with the same problem. Both must determine the method 
 of sectioning a resource, sheet metal for one, CORE for the other, in a manner 
 which minimizes the wasted resource. We view the resource requests as two- 
 dimensional requests, that is length and width of sheet metal or amount of 
 memory and period of time it is needed. The two organizations turn to linear 
 programming techniques and use the cutting-stock solution obtained. The foundry 
 operator applies his solution, minimizes his waste, and smiles all the way to 
 the bank. The management of the computer center, on the other hand, has dis- 
 covered a truly unsettling result. As they begin to divide their resource 
 among the users, they find that the user must now have his portion of the 
 resource for a longer period of time. 
 
20 
 
 We have seen in chapter 2, the cause of this elongation. It is, in fact, 
 a direct result of the portioning of the resource among more than one user, or 
 multiprogramming. The results of the cutting stock problem could have been 
 used if the user or the computer center management could have guessed the 
 actual length of time that the memory resource was needed. Unfortunately, the 
 actual length of time is dependent not only upon the user job, but, as we have 
 seen, upon the nature and number of other jobs being concurrently processed. 
 Having had this exit barred, we must now turn to another. 
 
 Codd [ h J has presented a technique for multiprogram scheduling which 
 suggests a solution to our problem. His method is sufficiently complex and 
 the results are important enough to warrant a detailed discussion of Codd ' s 
 method. From our point of view the primary limitation to Codd's method is that 
 it is based on elapsed time. As we have seen, the elapsed time of a job is a 
 function of the nature and number of other jobs in the system. Any a priori 
 estimate of the elapsed time of a job is more likely than not to be in error. 
 Some [ 3 J would argue even as to the appropriateness of active time, since 
 active time is dependent on various idiosyncracies of the program such as 
 amount of input or number of iterations required to find a root of a polynomial. 
 We will answer by saying that even if the active time is only a least upper 
 bound, the estimate of elapsed time which can be calculated at execution time 
 will be much more accurate than an elapsed time estimate which may be too 
 short when five programs are running and too long when two programs are running. 
 We proceed with a discussion of Codd's multiprogram scheduling algorithm. 
 
 The scheduling algorithm is designed to deal with two types of facilities, 
 space-shared facilities and time-shared facilities. We will deal only with 
 space-shared facilities, since the aspects of the time-shared facility, the CPU, 
 
21 
 
 are included in our definitions of the CPU allocation factor, T.(t). Each 
 job which enters the system appears as a pair (ei. ,r.) representing the 
 elapsed time and resource request, respectively . The pair (e&. ,r.) will be 
 treated as a rectangle and the goal is to place these rectangles within the 
 larger rectangle whose dimensions are limited by the total amount of the 
 resource, R, and the unbounded time axis. We will use the terms rectangle 
 and job synonymously. 
 
 The rectangles are placed in the time-space area using five rules. These 
 rules will be briefly described. 
 
 Rule 1. The resource is bounded by two load limits, B and b. B, the upper 
 limit, is equal to R the total amount of resource, b, the lower limit is set 
 arbitrarily. Each placement must satisfy the following three criteria. 
 
 1) Before program P is placed the sum of the resource requests must be 
 less than b. 
 
 2) After P is placed, the sum of the resource requests must be less than 
 or equal to B. 
 
 3) The rectangle which represents P must not intersect another rectangle. 
 Rule 2. Each program must be placed in the leftmost eligible position. 
 Inserted idle time is not necessary nor desirable. 
 
 Rule 3. A program may not be placed in a position which would entail more 
 
 than one schedule test. 
 
 Rule 4. Each program must be placed such that its upper or lower edge is 
 
 completely bordered by another program or the upper or lower edge of the 
 
 resource axis. 
 
 Rule 5. Once a program is assigned a portion of space, it may not be moved to 
 
 another portion. In other words execution time relocation is not allowed. 
 
22 
 
 Using these rules, Codd has proceeded to develop a scheduling algorithm. Two 
 concepts are basic to this algorithm. They are the concept of a step and a 
 pyramid. We will deal with the pyramid concept first. The concept of a 
 pyramid is a direct result of the application of Rule 4. A pyramid consists 
 of a set of rectangles which have been stacked upon one another. As a conse- 
 quence of Rule 4, each layer must be less than or equal in length to the 
 previous layer. The base of the pyramid must lie on either the upper or lower 
 boundary of the resource map and must be greater than or equal to any other 
 level of the pyramid. An exception to the rule that each layer be less than 
 or equal to the preceding layer is made when an upper and lower pyramid meet. 
 Several examples of pyramids are shown in Figure 3.1. 
 
 The concept of a step is provided as a method of dealing with the discon- 
 tinuities which arise from the creation of a pyramid. A step is associated 
 with either an upper or lower pyramid and consists of a start time and a length. 
 Using a step, we may then determine whether a program with a given elapsed 
 time can be used to further the construction of a pyramid without violating 
 Rule 4. Since the addition of each program to the schedule will change the 
 values and number of steps we present the algorithm which govern their creation. 
 The algorithm applies equally to upper or lower levels but we will present it 
 only from the lower level viewpoint. The upper level algorithm may be obtained 
 by interchanging upper and lower in each step of the algorithm. 
 
 We will define the top of a pyramid as that level which is completely 
 
 exposed, i.e. has no level above it. The length of the top level will be 
 
 called d . The null pyramid is one in which the lower level of the resource 
 
 axis is exposed. The length of the top level of a null pyramid is d = °°. We 
 
 will use s and d to represent the starting time and duration of job P. The 
 P P 
 
23 
 
 cgwwo:d«ow 
 
 D & M EH CQ 
 
24 
 
 symbol x t will represent the start of the level and the use of a prime will 
 denote a level in the opposite list. Upon placement of job P, we will create 
 at most three new steps from the step (x ,d ). They are 
 
 (x t ,s p -x t ) (5) 
 
 Cs p ,d p ) . (6) 
 
 and 
 
 (s +d ,x +d -s -d ) . (7) 
 
 ppttpp M/ 
 
 If the step immediately preceding (x t ,d ) in the opposite list meets the con- 
 dition x 1 -,+d 1 >x <-> tnen we will replace the step (x f , ,d' ) with the 
 two steps 
 
 (x t-l' X t" X t-l } (8) 
 
 and 
 
 (x i ,d t . 1 -x t+ x'. 1 ) . . (9) 
 
 Since jobs can only be scheduled at the termination of some other job, then s 
 must equal some x already in the list. If, in fact, s = x then equation (1) 
 results in a step of zero duration and may be dropped. In general, if the 
 duration of any step becomes zero, that step may be removed from the list. 
 
 Using the step list which has been described above and a list, initially 
 empty, of jobs which have been scheduled, Codd now proceeds to schedule the 
 next unscheduled job. He locates the first step which is long enough to con- 
 tain the job. If the current resource level usage is such that the inclusion 
 of the job would exceed the upper limit, B, then the next starting time on this 
 step is found. The search on this step will continue as long as there remains 
 sufficient time to complete the job. If no such position is found, then the 
 
25 
 
 next step is examined. When a job is finally placed in the schedule, the 
 step list is updated as described above. 
 
 We have already discussed the problems inherent in the use of elapsed 
 time for scheduling purposes. It is important to note that even the use of 
 programmer-supplied active and passive times with the CPU allocation factor 
 may not provide an accurate estimate of elapsed time. Through the enforcement 
 of termination upon exceeding the specified active time, it can usually be 
 guaranteed that the calculated elapsed time will not be exceeded. Unfor- 
 tunately, there is no guarantee that the program will not use less than the 
 requested amount of active time. 
 
 Having presented Codd's algorithm, we will now discuss a few modifications 
 in an attempt to improve the algorithm. Our primary modification will be the 
 use of computed run times based on the programmer or system supplied active 
 and passive times. From our discussion of multi-programming effects we have 
 noted that a prolongation in run time occurs whenever a job receives less than 
 the maximum CPU allocation factor which it can use. The maximum CPU alloca- 
 tion factor, t. , is defined as ratio of active time to execution time or 
 1 
 max 
 
 a. 
 
 T i = a~^T ' (1 °) 
 
 max 1 r i 
 
 Thus when the number of iobs being executed, n, is such that — > T. then 
 
 max 
 job i will not suffer a prolongation of run time. Since we wish to make 
 
 extensive use of the previous work, we must take this prolongation effect into 
 
 account . 
 
 We use these results by first ordering our list of unscheduled jobs in 
 
 decreasing execution time, a.+p., within decreasing T. . The reason for 
 
 11 l 
 
 max 
 
 this ordering is two-fold. First, we wish to keep the longer running jobs to 
 
26 
 
 the outside of the resource area. By maintaining the list of unscheduled jobs 
 
 in decreasing order of execution time, which, by definition, is the minimum 
 
 time for the job to complete, we guarantee that even if another job is placed 
 
 above the first job and both are processed at T. , the first iob will not 
 
 l 
 max 
 
 complete before the second job. Second, since jobs with equal execution 
 
 times are maintained in order of decreasing T. , we insure that even if they 
 
 max 
 are processed at less than t. , the first job will suffer greater prolonga- 
 
 max 
 tion of run time than the second job. 
 
 To illustrate, let two jobs k and & with equal execution times appear in 
 
 the order k, i in the list of unscheduled jobs. The execution time, E, is 
 
 then given by 
 
 E = a, /t = a ,/t . (11) 
 
 k w max £ *max s 
 
 Since T *T , then a, > a „. The method used to determine T. (t) 
 , max — .max ' k _ * l v 
 
 k I 
 
 insures that ^(t) = T £ (t) or T fc (t) > T f (t) = r £ . If T fc (t) = T ^(t), then 
 
 max 
 
 job I. will finish first, since a > a . If T (t) > T.(t) = T , then job 
 
 k * k * ,«max 
 
 & finishes first or at the same time, since a^/f ^^ = E is the minimum 
 
 jnax 
 
 execution time and T, (t) < T which would require iob k to finish either at 
 
 k , max J 
 
 k 
 
 the same time or later than job i. 
 
 Our strategy is then to move down the unscheduled list inspecting each job. 
 Using the resource usage parameter, r., of the 3-tuple which defines the next 
 job, we determine whether the inclusion of this job in the current schedule 
 will exceed the amount of available resource, R. If this job will fit, resource- 
 wise, then we must check to see if it can be used to build the next layer of a 
 pyramid. Since we are dealing with a dynamic system, we will consider the 
 scheduling interval to be that interval between the present moment (set to 
 
27 
 
 zero at the beginning of each interval) and the earliest termination of a job 
 executing in that interval. We have already discussed the treatment of jobs 
 which extend into the next scheduling interval. 
 
 At the beginning of each scheduling interval a step list will exist which 
 contains a list of the eligible positions for a job and the length of that 
 position. The elements of the step list are of two types: 1) those steps 
 which are formed from the exposed sections of pyramids whose bases lie on the 
 lower level of the resource map, termed lower level steps; 2) those steps which 
 are formed from the exposed sections of pyramids whose bases lie on the upper 
 limit of the resource map, termed upper level steps. This step list will con- 
 tain either two elements of the type (0,t,X) where t is the duration of the 
 step and X represents a lower or upper step, or it will contain no elements 
 of the type (0,t,X). From the construction of the pyramids, only those jobs 
 which form the highest (lowest) levels of a lower (upper) pyramid may terminate 
 in a given scheduling interval. As a result, the resource which is freed is 
 contiguous and can be represented by the two step list elements (0,t ,U) and 
 (0,t ,L). Because of our definition of the scheduling interval, the pyramids 
 
 Ju 
 
 which exist at the beginning of any interval are always left justified. 
 
 Initially, the step list contains two entries: (0,°=,!) and (Oj^jU). The 
 
 first job is then guaranteed to fit on an available step. When this job is 
 
 placed in the schedule, then the step list is updated by replacing the entry 
 
 (0,°°,L) with the entries (0,a /t l) and (a 1 /t ,°°,L). The resource usage 
 
 1 ,max' 1 max' ' ' ° 
 
 for this iob is added to the current resource usage level, R . The next job 
 
 J c 
 
 which satisfies r < R-R is then located. Upon placing this job in the 
 l — c . 
 
 schedule, we now recalculate the T.(t) for the two jobs and replace the step 
 list entry (0,a /t ,L) with the two entries (0,a„/T (t),L) and 
 
28 
 
 a 2 Vt^V" 
 
 ( T / t x , ~ , L). The step list entry for (- , °°,L) 
 
 2 max max 
 
 a 2 a 2 T l (t) 
 is replaced by (- + (a^ - (t) )(" ) , CC ,L). 
 
 2 2 max 
 
 In general, the method for updating the step list is identical to that 
 proposed by Codd. Specific differences, which are mainly redactions in the 
 amount of work done, are a result of the restriction that we may only schedule 
 jobs on the two steps which start at 0, namely (0,t U) and (0,t ,L) . Since 
 the size of the steps are determined by the jobs which are being run during 
 the scheduling interval, we need not maintain the steps which do not fall in 
 the current scheduling interval. Thus, we need only know the length of the 
 last scheduling interval and the CPU allocation factor, T.(t), for each job 
 during that interval. From this information we may then determine the amount 
 of active time remaining for those jobs which are present at the beginning of 
 this new interval. 
 
 To illustrate the above techniques, we will use them to schedule a group 
 
 of jobs. The jobs to be scheduled are shown in Table 3.1. Note that we have 
 
 provided t , the maximum CPU allocation factor, instead of the passive 
 r .max' ' r 
 
 i 
 
 time, p.. We will schedule these jobs on a contiguous memory resource which 
 is four resource units large. The overlap factor is assumed to be equal to 
 unity. We further assume that no jobs enter the system after the first 
 scheduling interval. 
 
 We start by taking the jobs P ,P ,P_, and P lf) . The resource usage level 
 is now four units. Upon calculation of the t. (t) for each of the jobs, and 
 dividing the active time for each job, we find the job P.. will finish in 
 37.08 seconds. When job P. _ completes, we check the unscheduled job list and 
 
29 
 
 find that no job in the list will fit in the remaining resource. We recal- 
 culate the t. (t) and find that this new scheduling interval will end at 
 212.79 seconds. At the beginning of the third interval, we find that the 
 resource usage level is only two units. Examining the unscheduled job list 
 
 we find that P. will fit in the remaining resource. In the fourth interval 
 4 
 
 we find that the next job, P , will not fit on the lower step which is above 
 P . To accommodate P we schedule it on the upper step. The process 
 
 Job 
 
 Active time 
 (sees) 
 
 T 
 
 . max 
 
 l 
 
 Resource Request 
 
 Execution Time 
 (sees) 
 
 1 
 
 60 
 
 .2 
 
 1 
 
 300 
 
 2 
 
 100 
 
 .66 
 
 1 
 
 150 
 
 3 
 
 80 
 
 .6 
 
 1 
 
 133 
 
 4 
 
 40 
 
 .3 
 
 2 
 
 133 
 
 5 
 
 50 
 
 .4 
 
 2 
 
 125 
 
 6 
 
 40 
 
 .4 
 
 2 
 
 100 
 
 7 
 
 30 
 
 .3 
 
 3 
 
 100 
 
 8 
 
 30 
 
 .5 
 
 3 
 
 60 
 
 9 
 
 20 
 
 .9 
 
 2 
 
 22 
 
 10 
 
 10 
 
 1 
 
 1 
 
 10 
 
 Table 3.1. Scheduling Data 
 
 in the above manner until all of the jobs have been scheduled. The final 
 schedule is graphically displayed in Figure 3.2. A Gantt chart has been pro- 
 vided in Figure 3.3 showing the CPU allocation factors used in each schedul- 
 ing interval. 
 
 We have thus demonstrated that there exist methods for deriving best-fit 
 type schedules for the class of constrained contiguous memory resources. 
 
30 
 
 
 a 
 
 Q 
 
 H 
 
 
 
 
 O 
 
 
 
 CO 
 
 Ph 
 
 O 
 
 
 
 
 LT\ 
 
 
 
 
 t- 
 
 Ph 
 
 
 
 
 
 
 
 
 
 
 Ph 
 
 Ph 
 
 -=t" 
 
 
 
 
 CVJ 
 
 u- 
 
 
 
 
 
 
 on 
 
 
 
 
 
 
 
 
 
 o 
 n 
 
 
 
 
 
 oo 
 
 
 
 -3- 
 P-l 
 
 H Q J W 
 
 
 
 OJ 
 
 
 
 
 OJ 
 
 OJ 
 H 
 
 
 
 
 
 
 
 OJ 
 
 
 
 
 
 
 O 
 H 
 
 
 oo 
 
 Ph 
 
 OJ 
 Ph 
 
 
 H 
 Ph 
 
 
 h- 
 
 
 
 
 
 
 
 
 00 
 
 O 
 H 
 
 Ph 
 
 
 
 en 
 
 O 
 O 
 
 cu 
 
 CO 
 CD 
 
 s 
 
 •H 
 
 CD 
 10 
 
 & 
 
 H 
 
 i-t 
 
 oo 
 cu 
 
 H 
 
 ■3 
 
 ■H 
 10 
 O 
 
 U 
 O 
 <h 
 
 CD 
 
 H 
 
 o 
 to 
 
 :>> 
 o 
 
 § 
 
 CO 
 O 
 
 •H 
 
 O 
 
 o 
 
 OJ 
 PO 
 
 g 
 
 OO OJ H 
 
 KWtflODKUH DSH&ra 
 
31 
 
 
 
 H 
 
 
 
 
 t-q 
 
 GO 
 
 
 
 O 
 
 Ph 
 
 
 
 H 
 
 
 
 
 
 t- 
 
 
 
 
 Ph 
 
 V£> 
 
 
 
 
 -=t 
 
 
 
 
 .rf 
 
 
 
 On 
 
 
 
 
 
 Ph 
 
 
 
 
 VD 
 
 
 
 
 
 
 Ph 
 
 
 
 
 
 
 LTN 
 Ph 
 
 CO 
 
 
 
 
 
 W 
 
 
 
 
 
 J 
 
 
 
 
 
 Q 
 
 
 
 
 
 H 
 
 
 
 
 f\l 
 
 
 
 
 
 \I\ 
 
 
 
 
 
 CM 
 
 
 
 
 
 
 
 H 
 
 
 
 
 
 Ph 
 
 
 
 CM 
 
 CO 
 
 
 
 
 Ph 
 
 Ph 
 
 
 
 
 
 
 o 
 
 
 
 
 
 
 H 
 
 
 
 
 
 
 Ph 
 
 
 VD 
 
 
 
 O 
 
 
 
 V£> 
 
 
 CM 
 
 vo 
 
 
 • 
 
 -3- 
 
 
 on 
 
 L^ 
 
 
 (L) 
 
 u 
 
 bO 
 •H 
 
 P>H 
 
 a 
 
 ■H 
 
 _-r 
 
 
 O 
 
 CM 
 
 *•""■"* 
 
 A-l 
 
 -=f 
 
 
 CO 
 
 
 C 
 
 CD 
 
 
 o 
 
 H 
 
 
 o 
 
 3 
 
 
 CD 
 
 -d 
 
 
 en 
 
 (1) 
 
 
 1 — ■ 
 
 Xi 
 
 
 CD 
 
 u 
 
 
 e 
 
 CO 
 
 
 •H 
 
 
 
 R 
 
 ?H 
 
 n 
 
 
 o 
 
 n 
 
 TJ 
 
 «H 
 
 on 
 
 CD 
 
 
 
 W 
 
 -p 
 
 
 P< 
 
 k 
 
 
 crt 
 
 cd 
 
 
 H 
 
 rC 
 
 
 W 
 
 o 
 
 -p 
 •p 
 
 CM 
 
 
 C 
 
 H 
 
 
 ctf 
 
 CM 
 
 
 on 
 on 
 
 H 
 
 ptH 
 
 CO 
 
 LTV 
 
 CM 
 
 O Ph D 
 
 <HHOO(j3-PtHOG 
 
32 
 
 3.2 Scheduling Fragmented Memory Resources 
 
 We have seen in the previous section that best-fit schedules do exist for 
 systems in which there is a single constrained memory resource of the con- 
 tiguous type. A logical question is then whether these methods may be applied 
 to the problem of determining a best-fit schedule for fragmented memory 
 resources. Examples of a fragmented memory resource are magnetic tape drives 
 or the CORE in a system which operates under a paging philosophy. The results 
 can, in fact, be applied to the problem of fragmented memory resources. But, 
 unfortunately, to accomplish this we would have to remove the freedom of 
 allocation which is inherent in the definition of fragmented memory resources 
 and treat them as contiguous resources. This seems hardly worth the effort 
 since the freedom of allocation in fragmented memory resources is an advantage 
 which we do not care to cast aside. 
 
 We must not be hasty, however, in discarding the techniques which have 
 been developed for contiguous memory resources. Our principal problem is 
 still one of covering the large resource- time rectangle, which represents the 
 computer system, as completely as possible with the smaller resource request- 
 time rectangles which represent the jobs to be run. We find that by employing 
 the definition of fragmented memory resources, a simplification exists which 
 will permit us to make use of previous results. In dealing with contiguous 
 memory resources we were required to manipulate rectangles whose resource 
 dimension was always equal to the resource usage parameter, r., of the job. 
 Fragmented resources, on the other hand, permit us to use up to r. rectangles 
 to represent the resource requirements of a job. 
 
 Once the freedom to use multiple rectangles has been achieved, we find 
 that the pyramid restriction is no longer necessary. We will show the reason- 
 ing behind the removal of this restriction and the resulting simplification 
 in the method. 
 
33 
 
 Let us assume that three jobs described by the 3-tuples (a.,p.,r.), 
 (a ,p ,r ) and (a «,p,,r^) have been scheduled for concurrent processing. 
 Furthermore let us assume that the jobs have been assigned adjacent resource 
 units. That is, units 1 through r. have been assigned to job j, units 
 r. - through r , . to job k and units r . through r . to job I. The 
 remaining R-r.-r -r, resource units are unassigned. Now if, in violation of 
 
 J K * 
 
 the pyramid rule, job k terminates before job SL, we will have two groups of 
 
 free resource units, one with r, free units and one with R-r -r, -r „ free 
 
 k j k I 
 
 units. For contiguous resources we would now be limited by scheduling jobs 
 
 with resource requirements, r. < max(r, ,R-r.-r, -r „) . However, since we are 
 
 i— k j k * 
 
 dealing with a fragmented resource we may schedule a job with a resource 
 
 request of r. < R-r.-r fl , the entire amount of free resource. 
 
 i - j V 
 
 Suppose that the job we wish to schedule has a resource usage of 
 r. < R-r.-r.. If r. < min(r ,R-r .-r -r J , then we may schedule it in either 
 
 J. & 1. K. K. X 
 
 area. If r. > max (r, ,R-r.-r, -r „) , then we will use two areas, one which is 
 l — k j k x 
 
 r . -max(r, ,R-r . -r -r .) , and the other which is max(r ,R-r .-r -r ,) . We may use 
 
 1. K. K. Xt K. K. Ju 
 
 any number of groups to arrive at the required number of resource units. We 
 see then that we are not concerned with the location of the free units, but 
 with the total quantity of the free resource units. As a consequence, we may 
 remove the pyramid restriction when dealing with fragmented resources. 
 
 Having removed the pyramid restriction, we are now able to treat the 
 scheduling of a job. Our algorithm for scheduling fragmented resources will 
 be as follows: 
 
 (1) Determine the length of the current scheduling interval by examining 
 all jobs which are currently processing and determining which one will finish 
 first and when it will finish. 
 
34 
 
 (2) Select a candidate job which has a resource request commensurate 
 with the free resource units. 
 
 (3) Calculate the tentative CPU allocation factors for this job and 
 the others which are currently being processed and using the tentative T.(t) 
 determine the length of the next scheduling interval and the amount of free 
 resource at the end of the interval. 
 
 (4) Note the tentative amount of free resource at the end of the new 
 interval if it is greater than or equal to the current amount. 
 
 (5) After checking every job which will fit the resource availability, 
 select the one which will result in the greatest amount of free resource at 
 the end of the next scheduling interval. 
 
 In order to demonstrate the use of the fragmented memory scheduling 
 
 algorithm, we present the following example. The jobs which are to be 
 
 scheduled, their active time, T , and their resource requirements are shown 
 
 . max 
 
 l 
 
 in Table 3.2. We will assume that all of the jobs are present at the begin- 
 ning of the first interval. The jobs have been ordered by decreasing resource 
 request and decreasing execution time. As in the example presented for the 
 contiguous memory case, we assume that O = 1 and that no jobs enter the system 
 after the beginning of the first scheduling interval. The fragmented memory 
 
 resource has an available resource amount, R. = 7. 
 
 l 
 
 Since at the start of the first interval, the resource usage is zero, we 
 
 may take any job. We will choose P.. , since its completion will release the 
 
 most resource. There are now 2 resource units left. Upon examining the jobs 
 
 which require 2 or less resource units we find that P, will finish at the same 
 
 6 
 
 time as P and 7 units will be available. At 133 seconds, when P and P, ter- 
 minate, we select P„ with a request of 4 units. To fill the remaining 3 units 
 
35 
 
 Table 3.2. Scheduling data for fragmented memory resource example 
 
 Resource request Execution time 
 
 (sees) 
 
 5 133 
 
 4 10 
 
 3 150 
 
 3 125 
 
 2 300 
 
 2 133 
 
 2 60 
 
 1 100 
 
 1 100 
 
 1 22 
 
 Job 
 
 Active time 
 (sees) 
 
 T 
 
 i 
 
 max 
 
 1 
 
 80 
 
 .6 
 
 2 
 
 10 
 
 1 
 
 3 
 
 100 
 
 .66 
 
 4 
 
 50 
 
 .4 
 
 5 
 
 60 
 
 .2 
 
 6 
 
 40 
 
 .3 
 
 7 
 
 30 
 
 .5 
 
 8 
 
 40 
 
 .4 
 
 9 
 
 30 
 
 .3 
 
 10 
 
 20 
 
 .9 
 
36 
 
 we will select P . Upon termination of P at 153 seconds, there are four 
 free resource units. We select P, for execution, since its termination will 
 release 3 units. P. is then assigned to the remaining 1 unit of resource. 
 
 o 
 
 Upon determination of the T. (t) we find that P. will terminate at 275 seconds 
 r 1 8 
 
 At that time we will schedule P q , which has a resource request of 1 unit. 
 We proceed in this manner until all of the jobs have been scheduled. The 
 entire schedule is presented in Figure 3.4. The T.(t) used in each schedule 
 are shown in the Gantt chart of Figure 3.5. 
 
 We have produced two algorithms for use in systems with a single con- 
 strained resource. The first is designed to deal with contiguous memory 
 resources, and the second is directed towards the problem of a fragmented 
 memory resource. 
 
37 
 
 H 
 O 
 VD 
 
 US 
 
 PL, 
 
 t— 
 
 H 
 O 
 
 on 
 
 
 t— 
 
 Ph 
 
 HQh-1H 
 
 o 
 H 
 
 PL, 
 
 P-, 
 
 on 
 
 LT\ 
 
 ON 
 
 Pm 
 
 CO 
 
 PL, 
 
 OJ 
 
 PL, 
 
 00 
 
 Ph 
 
 PL, 
 
 \D 
 
 TJV 
 
 P-, 
 
 LT\ 
 
 .. — » 
 
 OJ 
 
 to 
 
 -3- 
 
 Ti 
 
 
 a 
 
 
 o 
 
 o-i 
 
 o 
 
 CO 
 
 CD 
 
 m 
 
 to 
 
 
 *. — ' 
 
 
 ci> 
 
 
 fi 
 
 
 •H 
 
 
 &H 
 
 
 >ti 
 
 
 0) 
 
 
 en 
 
 LT\ 
 
 P-i 
 
 t~- 
 
 cd 
 
 OJ 
 
 W 
 
 CVI 
 
 oo 
 <u 
 
 H 
 
 ■s 
 
 En 
 
 a 
 
 •H 
 CO 
 
 o 
 
 ■rD 
 
 in 
 
 O 
 
 2 
 
 v 
 
 o 
 co 
 
 J>> 
 U 
 
 1 
 
 S 
 -p 
 
 a 
 
 J- 
 on 
 
 8 
 
 en oj 
 
 EWfflODKOW DSMEHCO 
 
38 
 
 CM 
 
 m 
 oo 
 on 
 
 LTN 
 t- 
 
 C\J 
 
 on 
 
 Ph 
 
 OO 
 
 Ph 
 
 oo 
 
 H 
 
 Pu 
 
 OJ 
 
 Ph 
 
 
 H 
 
 Ph 
 
 TTY- 
 
 TT 
 
 Ph 
 
 TTT" 
 OJ 
 
 o 
 
 
 
 vo 
 
 
 on 
 
 •H 
 
 Pn 
 
 c 
 
 H 
 
 
 ■H 
 
 t- 
 
 
 
 J- 
 
 
 O 
 
 
 ^-^ 
 
 CO 
 
 
 W 
 
 
 
 <rt 
 
 <u 
 
 
 M 
 
 H 
 
 
 o 
 
 pl 
 
 vo 
 
 o 
 
 >d 
 
 r— 
 
 03 
 
 (Li 
 
 on 
 
 en 
 
 ^ 
 
 
 ^— s 
 
 a 
 
 
 0) 
 
 to 
 
 
 6 
 
 
 
 ■H 
 
 U 
 
 
 &H 
 
 o 
 
 H 
 
 -d 
 
 
 n 
 
 CD 
 
 -p 
 
 oo 
 
 w 
 
 u 
 
 
 Ph 
 
 cti 
 
 
 cti 
 
 fl 
 
 
 H 
 
 o 
 
 
 H 
 
 -p 
 -P 
 
 on 
 
 on 
 
 
 w 
 
 H 
 
 
 C3 
 H 
 
 t-H 
 
 oPnp <lHHOCjaip-HOC 
 
39 
 
 4. MULTIPLE MEMORY CONSTRAINTS 
 
 We have seen that when there is only a single constrained memory resource, 
 certain techniques may be used to derive schedules which will tend to minimize 
 the amount of idle resources. In some systems this single resource approach 
 may be all that is necessary. Computer centers, such as those sometimes 
 found in academic environs (which are subject to workloads involving infrequent 
 requests for magnetic tape drives) will find that the critical resource is CORE. 
 In centers of this type the scheduling is most sensitive to resource requests 
 for CORE and, as a result, the method for scheduling a single contiguous memory 
 resource would be more than adequate. Other centers may find that a fragmented 
 memory resource is the dominating factor, and will use the fragmented memory 
 resource technique. 
 
 The important point in the above cases is that only the dominating con- 
 strained memory resource need be considered in effectively scheduling jobs. 
 We direct our attention in this chapter to those systems in which there are more 
 than one constrained memory resource. 
 
 In systems with multiple constrained memory resources we have two objectives 
 First, we hope to schedule the jobs in a manner which will minimize the idle 
 portion of each memory resource. Second, we desire a schedule which will tend 
 to balance the queue lengths between the various resources (that is we want to 
 avoid the formation of large queues that naturally result when one resource is 
 dominant in scheduling) . The problem of achieving these two goals and thus pro- 
 viding a well balanced schedule is a difficult one. We have not yet found a 
 general solution to this problem and in the following we will only describe the 
 various facets of the general solution presenting possible points of departure, 
 for future research. 
 
40 
 
 Systems which have multiple constrained memory resources are dynamic. 
 Owing to variations in the workload, the critical constrained resource (the one 
 which most affects overall performance) may change. These variations can cause 
 a shift in emphasis from a fragmented resource to a contiguous resource, or 
 even result in the system becoming a single constrained memory resource system. 
 Our method must be sensitive to these variations if it is to be effective. 
 
 In viewing a system with multiple resource constraints, we consider the 
 system to be an n+1 dimensional solid. This solid is composed of the real time 
 axis and n other dimension which are the n different resources of the system. 
 Jobs to be scheduled on this system may then be viewed as small n+1 dimensional 
 solid which are to be packed in the larger solid which is the system. 
 
 Denning [3J has suggested that "resource allocation is then a matter of 
 balancing memory and processor demands against equipment." While his orientation 
 is one of a paged system, and is concerned with determining the best set of 
 pages to maintain in memory, the balancing concept appears to be a useful one. 
 The balancing act which we must perform is, indeed, a tricky one. In selecting 
 jobs which would return the system to a "balanced" state, we must insure that 
 their selection will not unbalance the system from another direction. 
 
 Our most obvious approach at this point is to use the same methods which 
 were developed for systems with single constrained memory resources. We define a 
 set of tolerance functions, T. (n,D) . The tolerance functions are functions of n, 
 the number of jobs in the queue which are requesting the resource i, and D, the 
 total demand of those jobs for resource i. Each tolerance function is designed 
 to produce a value which indicates how much idle time we are willing to accept 
 on a given resource. For a resource which is not constrained, then T. (n,D) < 
 for all values of n and D. Critical resources, on the other hand, will have 
 tolerance functions which are always large. 
 
41 
 We are now ready to attempt to schedule jobs. The candidate job is 
 tentatively placed in the schedule and the amount of idle resources caused by 
 the placement of this job are measured against the tolerance functions. If any 
 of the tolerance functions are exceeded, we note the amount, the job is deferred, 
 and the search continues until we find a job which meets the tolerance function 
 restrictions. If no job can be found which meets the restrictions we then 
 choose the one which least exceeds the tolerance functions. 
 
 The concept of a tolerance function provides us with a rather convenient 
 solution to our scheduling problem. Unfortunately, the a priori determination 
 of the exact form of the tolerance function for a given resource presents a 
 somewhat formidable task. This problem results from the fact that the toler- 
 ance function may depend on the nature of the resource, its value to the system, 
 and the importance of the users which are demanding this resource, in addition 
 to the size of the queue and total demand for this resource. However, because 
 of the method in which the tolerance functions are used, the tolerance func- 
 tions can be easily changed and thus can be tuned to reflect local needs and 
 desires . 
 
 Suppose that a particular tolerance function is suspected to be a linear 
 function of the form T. (n,D) = An+BD+C, where A, B, and C are unknown coefficients 
 and n and D are determined from system values. Initially, we might assign values 
 of A = 1, B = 1, and C = 0. This assignment has the effect of treating resource 
 demand and queue size as equally important terms and since the value of this 
 function is always non-negative, we see that the resource will be treated as 
 a critical resource. If the nature of the resource is such that it only becomes 
 critical at some higher values of queue size and total demand, then we could 
 assign some negative value to the constant, C. With a tolerance function of the 
 form T. (n,D) = n+D-C, we find that the resource is scheduled as a non-critical 
 
42 
 
 resource until the sum of the queue size and the resource demand exceeds the 
 value of C, and then as a critical resource at higher values. 
 
 Similar adjustments can be made to the coefficients A and B. If we find 
 that the nature of the workload is such that each job requests only a few 
 units of the resource, then we might wish to make T. (n,D) more responsive to 
 queue size by increasing the value of A. On the other hand, if we wish to be 
 more responsive to jobs which demand large portions of the resource we might 
 increase the value of B and thus cause the scheduling emphasis on total 
 resource demand rather than on queue size. The above argument has been pre- 
 sented for a linear function. Similar methods can be used in cases where the 
 tolerance function is non-linear. 
 
 We see then that, in lieu of an obvious relationship, a rough function 
 which meets some of the operating system's requirements can be provided. 
 Then through subsequent analysis additional terms may be added and changes 
 made to the coefficients to improve the agreement of the tolerance function 
 with the needs and desires of the computer system, and provide effective sched- 
 uling of the constrained memory resources. 
 
 We present the following example to demonstrate the method of scheduling 
 a system in which there are two constrained memory resources. For this example, 
 we will use one resource, C, which is contiguous and one resource, F, which 
 is fragmented. The amounts of available resource will be R = 4 and R = 7. 
 The overlap factor used will be unity. We will assume that the tolerance 
 functions have been previously determined to be: 
 
 T c (n,D) = n+D 
 T F (n,D) = n+D . 
 
43 
 
 The jobs which we will schedule are shown in Table 4.1. They are the 
 same jobs we have used in prior examples with the exception that this time 
 we will be dealing with two resource requests instead of one. The jobs are 
 ordered as they were for the contiguous memory resource example. 
 
 Figures 4.1 and 4.2 depict the schedule in terms of the two memory 
 resources. Table 4.2 shows the progress of the schedule. We will not dis- 
 cuss the creation of the schedule to any depth, since almost all of the cal- 
 culations have been presented at one time or another. One item we will discuss 
 is the decision made at 271 seconds into the schedule. At this point we had 
 four jobs left to schedule. Upon inspecting the tolerance functions, we find 
 that the fragmented memory is more critical (T > T ). We chose to schedule 
 P„ instead of P_ , P c or P_ since only this choice would reduce the critical 
 fragmented resource usage more than it would the contiguous resource usage. 
 
Table 4.1. Set of jobs for 2-resource example 
 
 44 
 
 Job 
 
 Active time 
 (sees) 
 
 T 
 
 .max 
 
 L 
 
 r c 
 
 r F 
 
 Execution time 
 (sees) 
 
 1 
 
 60 
 
 .2 
 
 1 
 
 2 
 
 300 
 
 2 
 
 100 
 
 .66 
 
 i 
 
 3 
 
 150 
 
 3 
 
 80 
 
 .6 
 
 i 
 
 5 
 
 133 
 
 4 
 
 40 
 
 .3 
 
 2 
 
 2 
 
 133 
 
 5 
 
 50 
 
 .4 
 
 2 
 
 3 
 
 125 
 
 6 
 
 40 
 
 .4 
 
 2 
 
 1 
 
 100 
 
 7 
 
 30 
 
 .3 
 
 3 
 
 1 
 
 100 
 
 8 
 
 30 
 
 .3 
 
 3 
 
 2 
 
 60 
 
 1 9 
 
 20 
 
 .9 
 
 2 
 
 1 
 
 22 
 
 10 
 
 10 
 
 1 
 
 1 
 
 4 
 
 10 
 
45 
 
 
 H 
 
 
 
 
 •J 
 
 
 
 
 Q 
 
 
 
 
 M 
 
 
 
 
 
 IT\ ' 
 
 
 
 Ph 
 
 
 o 
 
 
 
 t- 
 
 
 H 
 
 
 -J- 
 
 
 
 Ph 
 
 
 
 OO 
 
 
 
 
 
 CU 
 
 
 CO 
 
 P-. 
 
 
 H 
 
 
 w 
 
 
 r— 
 
 
 
 p 
 
 
 OJ 
 
 
 
 On 
 
 M 
 
 
 OJ 
 
 Pk 
 
 
 
 
 H 
 
 
 -d" 
 
 
 OJ 
 
 
 Ph 
 
 
 
 VD 
 
 
 
 
 P-, 
 
 
 P-. 
 
 on 
 
 
 
 
 on 
 
 
 H 
 
 Ph 
 
 CM 
 
 P-, 
 
 
 
 OJ 
 
 
 • 
 
 
 _=f 
 
 
 <D 
 
 
 H 
 
 LT\ 
 
 P 
 
 OO 
 
 ti 
 
 ir\ 
 
 EH 
 
 
 
 o 
 
 
 
 A 
 
 
 
 cq 
 
 
 
 a; 
 
 
 
 H 
 
 O 
 
 
 2 
 
 VD 
 
 
 Ti 
 
 -3- 
 
 
 0) 
 
 o 
 
 
 . — ^ 
 
 en 
 
 
 w 
 
 
 
 T* 
 
 CD 
 
 
 c 
 
 ,C 
 
 
 o 
 
 +3 
 
 
 o 
 
 
 
 a; 
 
 ^ 
 
 o 
 
 w 
 
 o 
 
 ^o 
 
 v_ ^ 
 
 Ch 
 
 on 
 
 CD 
 
 
 
 S 
 
 
 
 
 •H 
 
 bl) 
 
 
 Eh 
 
 cti 
 ra 
 
 o 
 
 TJ 
 
 2 
 
 o 
 
 0) 
 
 
 on 
 
 w 
 
 CD 
 
 
 ft 
 
 o 
 
 o 
 
 H 
 
 ^ 
 
 i/\ 
 
 W 
 
 o 
 
 c\j 
 
 
 C/3 
 
 CD 
 
 LC\ 
 
 
 !h 
 
 CVJ 
 
 
 
 OJ 
 
 
 CO 
 
 o 
 
 w 
 
 •H 
 
 -p 
 
 o 
 
 o 
 
 H 
 
 • 
 
 -ST 
 
 w 
 
 C5 
 M 
 
 00 ■ OJ H 
 
46 
 
 
 
 
 H 
 
 
 
 
 
 
 
 
 
 
 
 w 
 
 
 
 
 
 
 
 Q 
 
 
 
 
 
 
 
 H 
 
 
 
 Ph 
 
 
 o 
 
 
 
 
 
 
 
 Ph 
 
 H 
 
 
 
 
 
 
 
 
 
 oo 
 
 
 
 
 
 
 
 P-, 
 
 
 
 oo 
 
 Ph 
 
 H 
 
 ^ 
 
 
 Ol 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 ON 
 
 
 H (: ,-l M 
 
 
 
 
 
 EL, 
 
 
 
 
 
 
 
 OJ 
 
 
 
 
 H 
 
 
 
 
 -3" 
 
 
 CM 
 
 
 
 
 d, 
 
 
 
 
 
 VD 
 
 W 
 
 
 
 
 
 
 
 Pn 
 
 h-l 
 
 o 
 
 
 
 
 
 rH 
 
 oo 
 
 
 
 
 
 
 
 Ph 
 
 en 
 
 
 
 H 
 
 -3- 
 
 Oh 
 
 
 
 OJ 
 
 Ph 
 
 
 
 
 
 OJ 
 
 
 
 _=r 
 
 
 
 o 
 
 
 
 H 
 
 ITN 
 
 
 ,0 
 
 OO 
 
 
 ctf 
 
 LT\ 
 
 
 &H 
 
 c 
 
 •H 
 
 o 
 
 -£ 
 
 en 
 <D 
 
 rH 
 
 O 
 
 
 2 
 
 VD 
 
 
 ^ 
 
 _=r 
 
 
 CD 
 V 
 
 
 ^~n 
 
 w 
 
 
 en 
 
 
 
 T3 
 
 <D 
 
 
 G 
 
 ,£ 
 
 
 o 
 
 -P 
 
 
 o 
 
 
 
 o 
 
 ^ 
 
 O 
 
 w 
 
 o 
 
 ^J 
 
 n y 
 
 «m 
 
 OO 
 
 0> 
 
 
 
 £ 
 
 CD 
 
 
 •H 
 
 t>0 
 
 
 EH 
 
 
 o 
 
 Ti 
 
 3 
 
 o 
 
 <D 
 
 
 OO 
 
 ft 
 
 QJ 
 
 
 w 
 
 o 
 
 
 ai 
 
 M 
 
 O 
 
 H 
 
 P 1 
 
 UN 
 
 W 
 
 O 
 
 CVI 
 
 
 C/} 
 CD 
 
 LT\ 
 
 
 M 
 
 CM 
 
 
 
 OJ 
 
 
 (L) 
 -P 
 
 CD 
 
 Ph 
 
 OJ 
 
 • 
 
 C5 
 
 H 
 Ph 
 
 t— VO LT\ _3" OO OJ rH 
 
 K H M O P ffi O W ,- pfeHEHCQ 
 
Table 4.2. Scheduling intervals for the 2 resource example. 
 * denotes the first appearance of a job in the 
 schedule . 
 
 47 
 
 Time 
 
 Job 
 
 Remaining 
 Active Time 
 
 T 
 
 .max 
 
 l 
 
 T.(t) 
 
 r c 
 
 r F 
 
 T c 
 
 T F 
 
 
 
 1* 
 
 60 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 26 
 
 31 
 
 
 2* 
 
 100 
 
 .66 
 
 .5 
 
 1 
 
 3 
 
 24 
 
 27 
 
 
 4* 
 
 40 
 
 .3 
 
 .3 
 
 2 
 
 2 
 
 21 
 
 24 
 
 133 
 
 1 
 
 33 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 
 
 
 2 
 
 33 
 
 .66 
 
 .4 
 
 1 
 
 3 
 
 
 
 
 6* 
 
 40 
 
 .4 
 
 .4 
 
 2 
 
 1 
 
 18 
 
 22 
 
 225 
 
 1 
 
 15 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 
 
 
 6 
 
 7 
 
 .4 
 
 .4 
 
 2 
 
 1 
 
 
 
 
 10* 
 
 10 
 
 1 
 
 .4 
 
 1 
 
 4 
 
 16 
 
 17 
 
 242 
 
 1 
 
 12 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 
 
 
 10 
 
 3 
 
 1 
 
 .4 
 
 1 
 
 4 
 
 
 
 
 9* 
 
 20 
 
 .9 
 
 .4 
 
 2 
 
 1 
 
 13 
 
 15 
 
 250 
 
 1 
 
 10 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 
 
 
 9 
 
 17 
 
 .9 
 
 .8 
 
 2 
 
 1 
 
 
 
 271 
 
 1 
 
 6 
 
 .2 
 
 .2 
 
 1 
 
 2 
 
 
 
 
 3* 
 
 80 
 
 .6 
 
 .6 
 
 1 
 
 5 
 
 11 
 
 9 
 
 300 
 
 3 
 
 61 
 
 .6 
 
 .5 
 
 1 
 
 5 
 
 
 
 
 8* 
 
 30 
 
 .5 
 
 .5 
 
 3 
 
 2 
 
 7 
 
 6 
 
 360 
 
 3 
 
 31 
 
 .6 
 
 .6 
 
 1 
 
 5 
 
 
 
 
 7* 
 
 30 
 
 .3 
 
 .3 
 
 3 
 
 1 
 
 3 
 
 4 
 
 410 
 
 7 
 
 15 
 
 .3 
 
 .3 
 
 3 
 
 1 
 
 
 
 460 
 
 5* 
 
 50 
 
 .4 
 
 .4 
 
 2 
 
 3 
 
 
 
 
 
48 
 5. CONCLUSION 
 
 In the foregoing we have presented a system for examining the effect of 
 interaction of multiprogrammed jobs. Using this system we then investigated 
 a class of best fit scheduling techniques. We have seen that a best fit 
 scheduling algorithm can be used to minimize the amount of idle resources and 
 at the same time provide a nearly optimal flowtime. The reduction in idle 
 resources which can be achieved at a given computing center will vary with 
 processor speed, amount of resources and other factors which are intrinsic to 
 a given computing center. 
 
 The ultimate result of using a best fit scheduling technique is to over- 
 lap CPU and memory usage and effectively compress the total flowtime for a 
 set of jobs. This results in an expansion of the usage of a given resource, 
 which promises to provide more efficient and effective resource utilization. 
 
 The class of best fit scheduling techniques is not intended to be the 
 ultimate in scheduling techniques for multiprogramming systems. The most 
 significant benefits of a best fit scheduling technique will be derived in 
 those systems where the workload consists of numerous independent jobs since 
 there is a potential to decrease the idle memory resources and increase through 
 put as a result of collecting those small fragments of idle memory into a usable 
 area . 
 
 The best fit techniques are not designed to operate in systems with large 
 networks of dependent jobs having tightly defined deadlines. In these systems 
 other techniques such as Cost Performance Monitoring-Program Evaluation 
 Review Techniques (CPM-PERT) must be investigated [6]. Unfortunately, the 
 CPM-PERT techniques can quickly become untractable when the networks grow 
 
49 
 
 Large or become networks of networks. Future research will be required not 
 only to improve the usability of CPM-PERT but also to provide insights into 
 methods of combining CPM-PERT with the best fit scheduling techniques 
 presented here. 
 
 This effort has resulted in one more step on the long journey toward total 
 computer system optimization. 
 
50 
 
 LIST OF REFERENCES 
 
 [l] Conway, R. W. , Maxwell, W. L., and Miller, L. W. , Theory of Scheduling , 
 Addison-Wesley , 1967. 
 
 [.2 J Baskett, F. , Browne, J. C, and Lan, J., "The Interaction of Multiprogram- 
 ming Job Scheduling and CPU Scheduling", Proc . FJCC , AFIPS Press, Montvale, 
 New Jersey, 1972, pp. 13-21. 
 
 [3] Denning, Peter J., "The Working Set Model for Program Behavior", Communi - 
 cations of the ACM, Volume 11, May, 1968, pp. 323-333. 
 
 [4] Codd, E. F., "Multiprogram Scheduling", Communications of the ACM , 
 
 Volume 3 (1960), pp. 347-350 (Part 1 6c 2) and pp. 413-418 (Part 3 and k) . 
 
 [5J Wagner, H. M. , Principles of Management Science with Applications to 
 Executive Decision , Prentice-Hall, 1970. 
 
 [6] Archibald, R. D. and Villoria, R. L. , Network-based Management Systems, 
 Wiley and Sons, 1967. 
 
 [7] Coffman, E. G. and Muntz, R. R., "Models of Pure Time-Sharing Disciplines 
 for Resource Allocation", Proc. ACM , I969, pp. 217-228. 
 
 [8] Belady, L. A. and Kuehner, C. J., "Dynamic Space-Sharing in Computer 
 
 Systems", Communications of the ACM , Volume 12, May 1969, pp. 282-288. 
 
 [9] Bernstein, A. J. and Sharp, J. C. "A Policy Driven Schedule for a Time- 
 Sharing System", Communications of the ACM , Volume 14, February 1971, 
 pp. 74-78. 
 
BIBLIOGRAPHIC DATA 
 SHEET 
 
 1. Report No. 
 
 UIUCDCS-R-7 1 +-678 
 
 3. Recipient's Accession No. 
 
 4. Title .ind Subt itle 
 
 Cost Minimization in Computer Systems Subject to 
 Multiple Memory Constraints 
 
 5- Report Date 
 
 October I97U 
 
 7. Authorf.v 
 
 Michael Austin Jamerson 
 
 8. Performing Organization Rept. 
 No - UIUCDCS-R-7U-678 
 
 9. Performing Organization Name and Address 
 
 University of Illinois at Urbana-Champaign 
 Department of Computer Science 
 Urbana, Illinois 6l801 
 
 10. Project/Task/Work Unit No. 
 
 11. Contract /Grant No 
 
 12. Sponsoring Organization Name and Address 
 
 Western Electric Company 
 2&V615 Ferry Road 
 Warrenville, Illinois 
 and 
 
 13. Type of Report & Period 
 Covered 
 
 Master of Science Thesis 
 
 14. 
 
 15. Supplementary Notes 
 
 University of Illinois at Urbana-Champaign, Department of Computer Science, 
 Urbana, Illinois 61801 
 
 16. Abstracts 
 
 The reconciliation of service requests with memory resource availabilities 
 presents a formidable problem for many computer service centers. When the 
 sum of the service requests for a given resource exceeds the amount of the 
 available resource, then that resource is constrained and scheduling 
 techniques must be used to maximize the utilization of that resource. Two 
 types of memory resource are considered, fragmented resources which can be 
 allocated in pieces and contiguous resources which may only be allocated in 
 one piece. An algorithm is developed which attempts to minimize the maximum 
 flowtime for a set of multiprogrammed jobs while minimizing the idle resources. 
 
 17. Key Words and Document Analysis. 17a. Descriptors 
 
 Constrained Memory Systems 
 Multiprogram Scheduling 
 Minimization of Idle Resources 
 Scheduling Constrained Resources 
 
 17b. Identifiers, 'Open-Ended Terms 
 
 17c. COSATI Fie Id /Group 
 
 18. Availability Statement 
 
 Release Unlimited 
 
 19. Security (lass (This 
 Report) 
 
 UNCLASSIFIED 
 
 20. Security Class (This 
 Page 
 
 UNCLASSIFIED 
 
 :i. No. oi t 1 
 
 52 
 
 22. Price 
 
 FORM NTIS-3S (10-70) 
 
 USCOMM-DC 40320-P: 
 
m ''' ;: ' T