Lottery and stride scheduling: flexible proportional-share resource management

This thesis presents flexible abstractions for specifying resource management policies, together with efficient mechanisms for implementing those abstractions. Several novel scheduling techniques are introduced, including both randomized and deterministic algorithms that provide proportional-share control over resource consumption rates. Such control is beyond the capabilities of conventional schedulers, and is desirable across a broad spectrum of systems that service clients of varying importance. Proportional-share scheduling is examined for several diverse resources, including processor time, memory, access to locks, and disk bandwidth. Resource rights are encapsulated by abstract, first-class objects called tickets. An active client consumes resources at a rate proportional to the number of tickets that it holds. Tickets can be issued in different amounts and may be transferred between clients. A modular currency abstraction is also introduced to flexibly name, share, and protect sets of tickets. Currencies can be used to isolate or group sets of clients, enabling the modular composition of arbitrary resource management policies. Two different underlying mechanisms are introduced to support these abstractions. Lottery scheduling is a novel randomized resource allocation mechanism. An allocation is performed by holding a lottery, and the resource is granted to the client with the winning ticket. Stride scheduling is a deterministic resource allocation mechanism that computes a representation of the time interval, or stride, that each client must wait between successive allocations. Stride scheduling cross-applies and generalizes elements of rate-based flow control algorithms designed for networks to dynamically schedule other resources such as processor time. A novel hierarchical stride algorithm is also introduced that achieves better throughput accuracy than prior schemes, and can reduce response-time variability for some workloads. The proposed techniques are compared and evaluated using a variety of quantitative experiments. Simulation results and prototype implementations for operating system kernels demonstrate flexible control over a wide range of resources and applications.

[1]  David A. Huffman,et al.  A method for the construction of minimum-redundancy codes , 1952, Proceedings of the IRE.

[2]  Edward G. Coffman,et al.  Analysis of Scanning Policies for Reducing Disk Seek Times , 1972, SIAM J. Comput..

[3]  M. Malik,et al.  Operating Systems , 1992, Lecture Notes in Computer Science.

[4]  C.M. Ellison,et al.  The Utah TENEX scheduler , 1975, Proceedings of the IEEE.

[5]  J. Larmouth Scheduling for a share of the machine , 1975, Softw. Pract. Exp..

[6]  Butler W. Lampson,et al.  Experience with processes and monitors in Mesa , 1980, CACM.

[7]  Kishor S. Trivedi Probability and Statistics with Reliability, Queuing, and Computer Science Applications , 1984 .

[8]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[9]  Reinhold Weicker,et al.  Dhrystone: a synthetic systems programming benchmark , 1984, CACM.

[10]  G. J. Henry,et al.  The UNIX system: The fair share scheduler , 1984, AT&T Bell Laboratories Technical Journal.

[11]  Maurice J. Bach The Design of the UNIX Operating System , 1986 .

[12]  William J. Bolosky,et al.  Mach: A New Kernel Foundation for UNIX Development , 1986, USENIX Summer.

[13]  Jeffrey Scott Vitter,et al.  Design and analysis of dynamic Huffman codes , 1987, JACM.

[14]  Gerry Kane,et al.  MIPS RISC Architecture , 1987 .

[15]  William H. Press,et al.  Numerical Recipes in FORTRAN - The Art of Scientific Computing, 2nd Edition , 1987 .

[16]  David E. Goldberg,et al.  Genetic Algorithms in Search Optimization and Machine Learning , 1988 .

[17]  Armando P. Stettner The design and implementation of the 4.3BSD UNIX operating system , 1988 .

[18]  Donald F. Ferguson,et al.  Microeconomic algorithms for load balancing in distributed computer systems , 1988, [1988] Proceedings. The 8th International Conference on Distributed.

[19]  Judy Kay,et al.  A fair share scheduler , 1988, CACM.

[20]  E. Drexler,et al.  Incentive engineering for computational resource management , 1988 .

[21]  K. Eric Drexler,et al.  Markets and computation: agoric open systems , 1988 .

[22]  V. Stavridou,et al.  Abstraction and specification in program development , 1988 .

[23]  S. K. Park,et al.  Random number generators: good ones are hard to find , 1988, CACM.

[24]  梅村 恭司 Andrew S.Tanenbaum 著, "Operating systems, Design and implementation", PRENTICE-HALL, INC., Englewood Cliffs, B5変形判, 719p., \4,120 , 1988 .

[25]  James W. Layland,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[26]  Carl A. Waldspurger,et al.  A distributed computational economy for utilizing idle resources , 1989 .

[27]  Donald Francis Ferguson,et al.  The application of microeconomics to the design of resource allocation and control algorithms , 1989 .

[28]  Scott Shenker,et al.  Analysis and simulation of a fair queueing algorithm , 1989, SIGCOMM '89.

[29]  F. A. Seiler,et al.  Numerical Recipes in C: The Art of Scientific Computing , 1989 .

[30]  William Pugh,et al.  Skip Lists: A Probabilistic Alternative to Balanced Trees , 1989, WADS.

[31]  Hogg,et al.  Dynamics of computational ecosystems. , 1989, Physical review. A, General physics.

[32]  David G. Carta,et al.  Two fast implementations of the “minimal standard” random number generator , 1990, CACM.

[33]  Lui Sha,et al.  Priority Inheritance Protocols: An Approach to Real-Time Synchronization , 1990, IEEE Trans. Computers.

[34]  Jeff A. Johnson,et al.  Improving user-interface responsiveness despite performance limitations , 1990, Digest of Papers Compcon Spring '90. Thirty-Fifth IEEE Computer Society International Conference on Intellectual Leverage.

[35]  Alan Burns,et al.  The Notion of Priority in Real-Time Programming Languages , 1990, Comput. Lang..

[36]  Samuel J. Leffler,et al.  The design and implementation of the 4.3 BSD Unix operating system , 1991, Addison-Wesley series in computer science.

[37]  Margo I. Seltzer,et al.  Disk Scheduling Revisited , 1990 .

[38]  Lixia Zhang VirtualClock: a new traffic control algorithm for packet-switched networks , 1991, TOCS.

[39]  John Wilkes,et al.  Disk scheduling algorithms based on rotational position , 1991 .

[40]  Srinivasan Keshav,et al.  Comparison of rate-based service disciplines , 1991, SIGCOMM '91.

[41]  Lixia Zhang VirtualClock: A New Traffic Control Algorithm for Packet-Switched Networks , 1991, ACM Trans. Comput. Syst..

[42]  A. Burns,et al.  Scheduling hard real-time systems: a review , 1991, Softw. Eng. J..

[43]  Abhay Parekh,et al.  A generalized processor sharing approach to flow control in integrated services networks-the single node case , 1992, [Proceedings] IEEE INFOCOM '92: The Conference on Computer Communications.

[44]  Eric A. Brewer,et al.  PRELUDE: A System for Portable Parallel Software , 1992, PARLE.

[45]  Tad Hogg,et al.  Spawn: A Distributed Computational Economy , 1992, IEEE Trans. Software Eng..

[46]  David R. Cheriton,et al.  Application-controlled physical memory using external page-cache management , 1992, ASPLOS V.

[47]  Mark A. Linton,et al.  Pacers: time-elastic objects , 1993, UIST '93.

[48]  R. Obenza,et al.  Rate monotonic analysis for real-time systems , 1993, Computer.

[49]  Joseph L. Hellerstein,et al.  Achieving Service Rate Objectives with Decay Usage Scheduling , 1993, IEEE Trans. Software Eng..

[50]  Michael P. Wellman A Market-Oriented Programming Environment and its Application to Distributed Multicommodity Flow Problems , 1993, J. Artif. Intell. Res..

[51]  Abhay Parekh,et al.  A generalized processor sharing approach to flow control in integrated services networks: the single-node case , 1993, TNET.

[52]  Yale N. Patt,et al.  The process-flow model: examining I/O performance from the system's point of view , 1993, SIGMETRICS '93.

[53]  Joseph Boykin,et al.  Programming Under Mach , 1993 .

[54]  Stefan Savage,et al.  Processor capacity reserves: an abstraction for managing processor usage , 1993, Proceedings of IEEE 4th Workshop on Workstation Operating Systems. WWOS-III.

[55]  Marvin Theimer,et al.  Using threads in interactive systems: a case study , 1993, SOSP '93.

[56]  Thomas E. Anderson,et al.  High-speed switch scheduling for local-area networks , 1993, TOCS.

[57]  Brandon Dixon,et al.  Concurrency in an O(log log N) Priority Queue , 1994, Canada-France Conference on Parallel and Distributed Computing.

[58]  Scott Shenker,et al.  Scheduling for reduced CPU energy , 1994, OSDI '94.

[59]  Bernard P. Zajac Applied cryptography: Protocols, algorithms, and source code in C , 1994 .

[60]  David L. Tennenhouse,et al.  Collaborative load shedding for media-based applications , 1994, 1994 Proceedings of IEEE International Conference on Multimedia Computing and Systems.

[61]  Stefan Savage,et al.  Processor capacity reserves: operating system support for multimedia applications , 1994, 1994 Proceedings of IEEE International Conference on Multimedia Computing and Systems.

[62]  William E. Weihl,et al.  Lottery scheduling: flexible proportional-share resource management , 1994, OSDI '94.

[63]  Nathaniel Rockwood Bogan,et al.  Economic allocation of computation time with computation markets , 1994 .

[64]  I. Stoica,et al.  A New Approach to Implement Proportional Share Resource Allocation , 1995 .

[65]  S.N. Bokhari The Linux Operating System , 1995, Computer.

[66]  Tad Hogg,et al.  Distributed Computation as an Economic System , 1995 .

[67]  Carl A. Waldspurger,et al.  Stride Scheduling: Deterministic Proportional- Share Resource Management , 1995 .

[68]  Dawson R. Engler,et al.  Exokernel: an operating system architecture for application-level resource management , 1995, SOSP.

[69]  Mark S. Squillante,et al.  Time-function scheduling: a general approach to controllable resource , 1995, SOSP.

[70]  Sanjoy K. Baruah,et al.  Fast scheduling of periodic tasks on multiple resources , 1995, Proceedings of 9th International Parallel Processing Symposium.

[71]  Peter Honeyman,et al.  Partially Connected Operation , 1995, Comput. Syst..

[72]  David R. Cheriton,et al.  A market approach to operating system memory allocation , 1996 .

[73]  S. Clearwater Market-based control: a paradigm for distributed resource allocation , 1996 .

[74]  Umesh Maheshwari,et al.  Charge-Based Proportional Scheduling , 1996 .

[75]  Michael P. Wellman,et al.  Market-oriented programming: some early lessons , 1996 .

[76]  K. Steiglitz,et al.  A computational market model based on individual action , 1996 .

[77]  Andrew D. Birrell,et al.  An Introduction to Programming with Threads , 1996 .