DOCSLIB.ORG

Condition Variables Review: Mesa Vs. Hoare Monitors

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Condition Variables Review: Mesa Vs. Hoare Monitors Review: Monitor with Condition Variables CS162 Operating Systems and Systems Programming Lecture 9 Synchronization, Readers/Writers example, Scheduling • Lock: the lock provides mutual exclusion to shared data – Always acquire before accessing shared data structure September 26th, 2016 – Always release after finishing with shared data – Lock initially free Prof. Anthony D. Joseph • Condition Variable: a queue of threads waiting for something inside a http://cs162.eecs.Berkeley.edu critical section – Key idea: make it possible to go to sleep inside critical section by atomically releasing lock at time we go to sleep – Contrast to semaphores: Can’t wait inside critical section 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.2 Review: Condition Variables Review: Mesa vs. Hoare Monitors • How do we change the RemoveFromQueue() routine to wait until • Need to be careful about precise definition of signal and wait. something is on the queue? Consider a piece of our dequeue code: – Could do this by keeping a count of the number of things on the queue while=(queue.isEmpty())={ dataready.wait(&lock);=//=If=nothing,=sleep (with semaphores), but error prone } • Condition Variable: a queue of threads waiting for something inside a item===queue.dequeue(); //=Get=next=item critical section – Why didn’t we do this? – Key idea: allow sleeping inside critical section by atomically releasing if=(queue.isEmpty())={ lock at time we go to sleep dataready.wait(&lock);=//=If=nothing,=sleep } – Contrast to semaphores: Can’t wait inside critical section item===queue.dequeue(); //=Get=next=item • Operations: • Answer: depends on the type of scheduling – Wait(&lock): Atomically release lock and go to sleep. Re-acquire – Hoare-style (most textbooks): lock later, before returning. » Signaler gives lock, CPU to waiter; waiter runs immediately – Signal(): Wake up one waiter, if any » Waiter gives up lock, processor back to signaler when it exits critical section or if it waits again – Broadcast(): Wake up all waiters – Mesa-style (most real operating systems): • Rule: Must hold lock when doing condition variable ops! » Signaler keeps lock and processor – In Birrell paper, he says can perform signal() outside of lock – » Waiter placed on ready queue with no special priority IGNORE HIM (this is only an optimization) » Practically, need to check condition again after wait 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.3 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.4 Extended Example: Readers/Writers Problem Basic Readers/Writers Solution W • Correctness Constraints: – Readers can access database when no writers – Writers can access database when no readers or writers R – Only one thread manipulates state variables at a time R • Basic structure of a solution: R – Reader() Wait=until=no=writers Access=data=base Check=out=– wake=up=a=waiting=writer – Writer() • Motivation: Consider a shared database Wait=until=no=active=readers=or=writers Access=database – Two classes of users: Check=out=– wake=up=waiting=readers=or=writer » Readers – never modify database – State variables (Protected by a lock called “lock”): » int AR: Number of active readers; initially = 0 » Writers – read and modify database » int WR: Number of waiting readers; initially = 0 – Is using a single lock on the whole database sufficient? » int AW: Number of active writers; initially = 0 » int WW: Number of waiting writers; initially = 0 » Like to have many readers at the same time » Condition=okToRead ==NIL » Only one writer at a time » Condition=okToWrite ==NIL 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.5 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.6 Code for a Reader Code for a Writer Reader()={ Writer()={ //=First=check=self=into=system //=First=check=self=into=system lock.Acquire(); lock.Acquire(); while=((AW=+=AR)=>=0)={ //=Is=it=safe=to=write? while=((AW=+=WW)=>=0)={ //=Is=it=safe=to=read? WW++; //=No.=Active=users=exist WR++; //=No.=Writers=exist okToWrite.wait(&lock); //=Sleep=on=cond var okToRead.wait(&lock); //=Sleep=on=cond var WWXX; //=No=longer=waiting WRXX; //=No=longer=waiting } } AW++; //=Now=we=are=active! AR++; //=Now=we=are=active! lock.release(); lock.release(); //=Perform=actual=read/write=access AccessDatabase(ReadWrite); //=Perform=actual=readXonly=access AccessDatabase(ReadOnly); //=Now,=check=out=of=system lock.Acquire(); //=Now,=check=out=of=system AWXX; //=No=longer=active lock.Acquire(); if=(WW=>=0){ //=Give=priority=to=writers ARXX; //=No=longer=active okToWrite.signal(); //=Wake=up=one=writer if=(AR====0=&&=WW=>=0) //=No=other=active=readers }=else=if=(WR=>=0)={ //=Otherwise,=wake=reader okToWrite.signal(); //=Wake=up=one=writer okToRead.broadcast(); //=Wake=all=readers Why broadcast() } lock.Release(); lock.Release(); } } Why Release the 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.7 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.8 Simulation of Readers/Writers solution Simulation(2) • Consider the following sequence of operators: • Next, W1 comes along: – R1, R2, W1, R3 while=((AW=+=AR)=>=0)={ //=Is=it=safe=to=write? WW++; //=No.=Active=users=exist • On entry, each reader checks the following: okToWrite.wait(&lock); //=Sleep=on=cond var while=((AW=+=WW)=>=0)={ //=Is=it=safe=to=read? WWXX; //=No=longer=waiting WR++; //=No.=Writers=exist } okToRead.wait(&lock); //=Sleep=on=cond var AW++; WRXX; //=No=longer=waiting } • Can’t start because of readers, so go to sleep: AR++; //=Now=we=are=active! AR = 2, WR = 0, AW = 0, WW = 1 • First, R1 comes along: • Finally, R3 comes along: AR = 1, WR = 0, AW = 0, WW = 0 AR = 2, WR = 1, AW = 0, WW = 1 • Next, R2 comes along: • Now, say that R2 finishes before R1: AR = 2, WR = 0, AW = 0, WW = 0 AR = 1, WR = 1, AW = 0, WW = 1 • Now, readers make take a while to access database • Finally, last of first two readers (R1) finishes and wakes up writer: – Situation: Locks released if=(AR====0=&&=WW=>=0) //=No=other=active=readers – Only AR is non-zero okToWrite.signal(); //=Wake=up=one=writer 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.9 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.10 Simulation(3) Questions • Can readers starve? Consider Reader()=entry code: • When writer wakes up, get: while=((AW=+=WW)=>=0)={ //=Is=it=safe=to=read? AR = 0, WR = 1, AW = 1, WW = 0 WR++; //=No.=Writers=exist • Then, when writer finishes: okToRead.wait(&lock); //=Sleep=on=cond var WRXX; //=No=longer=waiting if=(WW=>=0){===========//=Give=priority=to=writers } okToWrite.signal(); //=Wake=up=one=writer AR++; //=Now=we=are=active! }=else=if=(WR=>=0)={ //=Otherwise,=wake=reader okToRead.broadcast(); //=Wake=all=readers • What if we erase the condition check in Reader exit? } ARXX; //=No=longer=active – Writer wakes up reader, so get: if=(AR====0=&&=WW=>=0) //=No=other=active=readers okToWrite.signal();= //=Wake=up=one=writer AR = 1, WR = 0, AW = 0, WW = 0 • Further, what if we turn the signal() into broadcast() • When reader completes, we are finished ARXX; //=No=longer=active okToWrite.broadcast();= //=Wake=up=one=writer • Finally, what if we use only one condition variable (call it “okToContinue”) instead of two separate ones? – Both readers and writers sleep on this variable – Must use broadcast() instead of signal() 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.11 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.12 Administrivia • Midterm on Wednesday 9/28 5-6:30PM – 1 LeConte (Last name A-H) and 2050 VLSB (Last name I-Z) – Topics include course material through lecture 9 (today) » Lectures, project 1, homeworks, readings, textbook – Closed book, no calculators, one double-side letter-sized page of handwritten notes – Review today 6:45-8:30PM in Hearst Field Annex A1 • No office hours on Mon10/3 (covering CS 262A) BREAK • Deadlines next week: – HW2 due next Monday (10/3) – Project 1 code due next Wednesday (10/5) – Project 1 final report due next Friday (10/7) 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.13 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.14 Can we Construct Monitors from Semaphores? Construction of Monitors from Semaphores (cont’d) • Locking aspect is easy: Just use a mutex • Problem with previous try: • Can we implement condition variables this way? – P and V are commutative – result is the same no matter what order they occur Wait()==={=semaphore.P();=} Signal()={=semaphore.V();=} – Condition variables are NOT commutative – Doesn’t work: Wait()=may sleep with lock held • Does this fix the problem? Wait(Lock=lock)={ • Does this work better? lock.Release(); Wait(Lock=lock)={ semaphore.P(); lock.Release(); lock.Acquire(); semaphore.P(); } lock.Acquire(); Signal()={ } if=semaphore=queue=is=not=empty Signal()={=semaphore.V();=} semaphore.V(); – No: Condition vars have no history, semaphores have history: } » What if thread signals and no one is waiting? NO-OP – Not legal to look at contents of semaphore queue » What if thread later waits? Thread Waits – There is a race condition – signaler can slip in after lock release and » What if thread V’s and no one is waiting? Increment before waiter executes semaphore.P() » What if thread later does P? Decrement and continue • It is actually possible to do this correctly – Complex solution for Hoare scheduling in book – Can you come up with simpler Mesa-scheduled solution? 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.15 2/22/16 Joseph CS162 ©UCB Spring 2016 Lec 9.16 Monitor Conclusion C-Language Support for Synchronization • Monitors represent the logic of the program • C language: Pretty straightforward synchronization – Wait if necessary – Just make sure you know all the code paths out of a critical – Signal when change
Load more

Recommended publications
  • Stclang: State Thread Composition As a Foundation for Monadic Dataflow Parallelism Sebastian Ertel∗ Justus Adam Norman A
    STCLang: State Thread Composition as a Foundation for Monadic Dataflow Parallelism Sebastian Ertel∗ Justus Adam Norman A. Rink Dresden Research Lab Chair for Compiler Construction Chair for Compiler Construction Huawei Technologies Technische Universität Dresden Technische Universität Dresden Dresden, Germany Dresden, Germany Dresden, Germany [email protected] [email protected] [email protected] Andrés Goens Jeronimo Castrillon Chair for Compiler Construction Chair for Compiler Construction Technische Universität Dresden Technische Universität Dresden Dresden, Germany Dresden, Germany [email protected] [email protected] Abstract using monad-par and LVars to expose parallelism explicitly Dataflow execution models are used to build highly scalable and reach the same level of performance, showing that our parallel systems. A programming model that targets parallel programming model successfully extracts parallelism that dataflow execution must answer the following question: How is present in an algorithm. Further evaluation shows that can parallelism between two dependent nodes in a dataflow smap is expressive enough to implement parallel reductions graph be exploited? This is difficult when the dataflow lan- and our programming model resolves short-comings of the guage or programming model is implemented by a monad, stream-based programming model for current state-of-the- as is common in the functional community, since express- art big data processing systems. ing dependence between nodes by a monadic bind suggests CCS Concepts • Software and its engineering → Func- sequential execution. Even in monadic constructs that explic- tional languages. itly separate state from computation, problems arise due to the need to reason about opaquely defined state.
    [Show full text]
  • APPLYING MODEL-VIEW-CONTROLLER (MVC) in DESIGN and DEVELOPMENT of INFORMATION SYSTEMS an Example of Smart Assistive Script Breakdown in an E-Business Application
    APPLYING MODEL-VIEW-CONTROLLER (MVC) IN DESIGN AND DEVELOPMENT OF INFORMATION SYSTEMS An Example of Smart Assistive Script Breakdown in an e-Business Application Andreas Holzinger, Karl Heinz Struggl Institute of Information Systems and Computer Media (IICM), TU Graz, Graz, Austria Matjaž Debevc Faculty of Electrical Engineering and Computer Science, University of Maribor, Maribor, Slovenia Keywords: Information Systems, Software Design Patterns, Model-view-controller (MVC), Script Breakdown, Film Production. Abstract: Information systems are supporting professionals in all areas of e-Business. In this paper we concentrate on our experiences in the design and development of information systems for the use in film production processes. Professionals working in this area are neither computer experts, nor interested in spending much time for information systems. Consequently, to provide a useful, useable and enjoyable application the system must be extremely suited to the requirements and demands of those professionals. One of the most important tasks at the beginning of a film production is to break down the movie script into its elements and aspects, and create a solid estimate of production costs based on the resulting breakdown data. Several film production software applications provide interfaces to support this task. However, most attempts suffer from numerous usability deficiencies. As a result, many film producers still use script printouts and textmarkers to highlight script elements, and transfer the data manually into their film management software. This paper presents a novel approach for unobtrusive and efficient script breakdown using a new way of breaking down text into its relevant elements. We demonstrate how the implementation of this interface benefits from employing the Model-View-Controller (MVC) as underlying software design paradigm in terms of both software development confidence and user satisfaction.
    [Show full text]
  • Process Scheduling
    PROCESS SCHEDULING ANIRUDH JAYAKUMAR LAST TIME • Build a customized Linux Kernel from source • System call implementation • Interrupts and Interrupt Handlers TODAY’S SESSION • Process Management • Process Scheduling PROCESSES • “ a program in execution” • An active program with related resources (instructions and data) • Short lived ( “pwd” executed from terminal) or long-lived (SSH service running as a background process) • A.K.A tasks – the kernel’s point of view • Fundamental abstraction in Unix THREADS • Objects of activity within the process • One or more threads within a process • Asynchronous execution • Each thread includes a unique PC, process stack, and set of processor registers • Kernel schedules individual threads, not processes • tasks are Linux threads (a.k.a kernel threads) TASK REPRESENTATION • The kernel maintains info about each process in a process descriptor, of type task_struct • See include/linux/sched.h • Each task descriptor contains info such as run-state of process, address space, list of open files, process priority etc • The kernel stores the list of processes in a circular doubly linked list called the task list. TASK LIST • struct list_head tasks; • init the "mother of all processes” – statically allocated • extern struct task_struct init_task; • for_each_process() - iterates over the entire task list • next_task() - returns the next task in the list PROCESS STATE • TASK_RUNNING: running or on a run-queue waiting to run • TASK_INTERRUPTIBLE: sleeping, waiting for some event to happen; awakes prematurely if it receives a signal • TASK_UNINTERRUPTIBLE: identical to TASK_INTERRUPTIBLE except it ignores signals • TASK_ZOMBIE: The task has terminated, but its parent has not yet issued a wait4(). The task's process descriptor must remain in case the parent wants to access it.
    [Show full text]
  • Scheduling: Introduction
    7 Scheduling: Introduction By now low-level mechanisms of running processes (e.g., context switch- ing) should be clear; if they are not, go back a chapter or two, and read the description of how that stuff works again. However, we have yet to un- derstand the high-level policies that an OS scheduler employs. We will now do just that, presenting a series of scheduling policies (sometimes called disciplines) that various smart and hard-working people have de- veloped over the years. The origins of scheduling, in fact, predate computer systems; early approaches were taken from the field of operations management and ap- plied to computers. This reality should be no surprise: assembly lines and many other human endeavors also require scheduling, and many of the same concerns exist therein, including a laser-like desire for efficiency. And thus, our problem: THE CRUX: HOW TO DEVELOP SCHEDULING POLICY How should we develop a basic framework for thinking about scheduling policies? What are the key assumptions? What metrics are important? What basic approaches have been used in the earliest of com- puter systems? 7.1 Workload Assumptions Before getting into the range of possible policies, let us first make a number of simplifying assumptions about the processes running in the system, sometimes collectively called the workload. Determining the workload is a critical part of building policies, and the more you know about workload, the more fine-tuned your policy can be. The workload assumptions we make here are mostly unrealistic, but that is alright (for now), because we will relax them as we go, and even- tually develop what we will refer to as ..
    [Show full text]
  • Scheduling Light-Weight Parallelism in Artcop
    Scheduling Light-Weight Parallelism in ArTCoP J. Berthold1,A.AlZain2,andH.-W.Loidl3 1 Fachbereich Mathematik und Informatik Philipps-Universit¨at Marburg, D-35032 Marburg, Germany [email protected] 2 School of Mathematical and Computer Sciences Heriot-Watt University, Edinburgh EH14 4AS, Scotland [email protected] 3 Institut f¨ur Informatik, Ludwig-Maximilians-Universit¨at M¨unchen, Germany [email protected] Abstract. We present the design and prototype implementation of the scheduling component in ArTCoP (architecture transparent control of parallelism), a novel run-time environment (RTE) for parallel execution of high-level languages. A key feature of ArTCoP is its support for deep process and memory hierarchies, shown in the scheduler by supporting light-weight threads. To realise a system with easily exchangeable components, the system defines a micro-kernel, providing basic infrastructure, such as garbage collection. All complex RTE operations, including the handling of parallelism, are implemented at a separate system level. By choosing Concurrent Haskell as high-level system language, we obtain a prototype in the form of an executable specification that is easier to maintain and more flexible than con- ventional RTEs. We demonstrate the flexibility of this approach by presenting implementations of a scheduler for light-weight threads in ArTCoP, based on GHC Version 6.6. Keywords: Parallel computation, functional programming, scheduling. 1 Introduction In trying to exploit the computational power of parallel architectures ranging from multi-core machines to large-scale computational Grids, we are currently developing a new parallel runtime environment, ArTCoP, for executing parallel Haskell code on such complex, hierarchical architectures.
    [Show full text]
  • Scheduling Weakly Consistent C Concurrency for Reconfigurable
    SUBMISSION TO IEEE TRANS. ON COMPUTERS 1 Scheduling Weakly Consistent C Concurrency for Reconfigurable Hardware Nadesh Ramanathan, John Wickerson, Member, IEEE, and George A. Constantinides Senior Member, IEEE Abstract—Lock-free algorithms, in which threads synchronise These reorderings are invisible in a single-threaded context, not via coarse-grained mutual exclusion but via fine-grained but in a multi-threaded context, they can introduce unexpected atomic operations (‘atomics’), have been shown empirically to behaviours. For instance, if another thread is simultaneously be the fastest class of multi-threaded algorithms in the realm of conventional processors. This article explores how these writing to z, then reordering two instructions above may algorithms can be compiled from C to reconfigurable hardware introduce the behaviour where x is assigned the latest value via high-level synthesis (HLS). but y gets an old one.1 We focus on the scheduling problem, in which software The implication of this is not that existing HLS tools are instructions are assigned to hardware clock cycles. We first wrong; these optimisations can only introduce new behaviours show that typical HLS scheduling constraints are insufficient to implement atomics, because they permit some instruction when the code already exhibits a race condition, and races reorderings that, though sound in a single-threaded context, are deemed a programming error in C [2, §5.1.2.4]. Rather, demonstrably cause erroneous results when synthesising multi- the implication is that if these memory accesses are upgraded threaded programs. We then show that correct behaviour can be to become atomic (and hence allowed to race), then existing restored by imposing additional intra-thread constraints among scheduling constraints are insufficient.
    [Show full text]
  • Fork-Join Pattern
    Fork-Join Pattern Parallel Computing CIS 410/510 Department of Computer and Information Science Lecture 9 – Fork-Join Pattern Outline q What is the fork-join concept? q What is the fork-join pattern? q Programming Model Support for Fork-Join q Recursive Implementation of Map q Choosing Base Cases q Load Balancing q Cache Locality and Cache-Oblivious Algorithms q Implementing Scan with Fork-Join q Applying Fork-Join to Recurrences Introduction to Parallel Computing, University of Oregon, IPCC Lecture 9 – Fork-Join Pattern 2 Fork-Join Philosophy When you come to a fork in the road, take it. (Yogi Bera, 1925 –) Introduction to Parallel Computing, University of Oregon, IPCC Lecture 9 – Fork-Join Pattern 3 Fork-Join Concept q Fork-Join is a fundamental way (primitive) of expressing concurrency within a computation q Fork is called by a (logical) thread (parent) to create a new (logical) thread (child) of concurrency ❍ Parent continues after the Fork operation ❍ Child begins operation separate from the parent ❍ Fork creates concurrency q Join is called by both the parent and child ❍ Child calls Join after it finishes (implicitly on exit) ❍ Parent waits until child joins (continues afterwards) ❍ Join removes concurrency because child exits Introduction to Parallel Computing, University of Oregon, IPCC Lecture 9 – Fork-Join Pattern 4 Fork-Join Concurrency Semantics q Fork-Join is a concurrency control mechanism ❍ Fork increases concurrency ❍ Join decreases concurrency q Fork-Join dependency rules ❍ A parent must join with its forked children
    [Show full text]
  • An Analytical Model for Multi-Tier Internet Services and Its Applications
    An Analytical Model for Multi-tier Internet Services and Its Applications Bhuvan Urgaonkar, Giovanni Pacificiy, Prashant Shenoy, Mike Spreitzery, and Asser Tantawiy Dept. of Computer Science, y Service Management Middleware Dept., University of Massachusetts, IBM T. J. Watson Research Center, Amherst, MA 01003 Hawthorne, NY 10532 fbhuvan,[email protected] fgiovanni,mspreitz,[email protected] ABSTRACT that is responsible for HTTP processing, a middle tier Java enterprise Since many Internet applications employ a multi-tier architecture, server that implements core application functionality, and a back- in this paper, we focus on the problem of analytically modeling the end database that stores product catalogs and user orders. In this behavior of such applications. We present a model based on a net- example, incoming requests undergo HTTP processing, processing work of queues, where the queues represent different tiers of the by Java application server, and trigger queries or transactions at the application. Our model is sufficiently general to capture (i) the database. behavior of tiers with significantly different performance charac- This paper focuses on analytically modeling the behavior of multi- teristics and (ii) application idiosyncrasies such as session-based tier Internet applications. Such a model is important for the follow- workloads, tier replication, load imbalances across replicas, and ing reasons: (i) capacity provisioning, which enables a server farm caching at intermediate tiers. We validate our model using real to determine how much capacity to allocate to an application in or- multi-tier applications running on a Linux server cluster. Our exper- der for it to service its peak workload; (ii) performance prediction, iments indicate that our model faithfully captures the performance which enables the response time of the application to be determined of these applications for a number of workloads and configurations.
    [Show full text]
  • Communication and Scheduling Model Design of Distributed Workflow Management System
    Advances in Engineering Research, volume 119 2nd International Conference on Automatic Control and Information Engineering (ICACIE 2017) Communication and Scheduling Model Design of Distributed Workflow Management System Jing Zhao Bin Wei School of Science Key Laboratory of Network & Information Security of APF Xijing University Engineering College of APF Xi’an, China, 710123 Xi’an, China, 710123 [email protected] Abstract—The traditional OA system cannot meet the requirements of modern enterprise. Currently the widely used II. DISTRIBUTED WORKFLOW MANAGEMENT SYSTEM distributed workflow management system (DWFMS) has the The WFMC propose a classic definition of workflow: all problem of load balancing, which makes the enterprise efficiency or part of it supported or automated by a computer. The unimproved. In this paper, on the study of the DWFMS, the workflow management system is to support a batch of model design of common communication transmission and professional set workflow, which is defined by the calculated scheduling are analyzed. Then the real-time scheduling strategy process. It is used to support the definition, management and model is put forward and discussed, which based on feedback control. By using this model in DWFMS, the task can be executive the workflow. It enable the business execution controlled effectively, the load balancing performance of the processes to achieve maximum efficiency. system is improved effectively, and the stability of the system is The distributed workflow system is generally divided into ensured. 3 parts: the distribution of workflow architecture, the distribution of workflow engine and the distribution of Keywords—workflow; communication; scheduling model; workflow model. The workflow engine distribution is the core controller of distributed system.
    [Show full text]
  • Computer Scheduling Methods and Their Countermeasures
    Computer scheduling methods and their countermeasures by EDWARD G. COFFMAN, JR* Princeton University Princeton, New Jersey A anu LEONARD KLEINROCK** University of California Los Angeles, California INTRODUCTION sources. In multi-access, multiprogramming systems The simultaneous demand for computer service by throughput may conveniently be measured in terms of members from a population of users generally results computer operating efficiency defined roughly as the in the formation of queues. These queues are con­ percentage of time the computer spends in perform­ trolled by some computer scheduling method which ing user or customer-directed tasks as compared with chooses the order in which various users receive at­ the time spent in performing executive (overhead type) tention. The goal of this priority scheduling algorithm tasks. We shall avoid trying to measure the program­ is to provide the population of users with a high mers' or users' productivity in a multi-access environ­ grade of service (rapid response, resource availabil­ ment as compared with productivity in the usually less ity, etc.(, at the same time maintaining an acceptable flexible but more efficient batch-processing environ­ throughput rate. The object of the present paper is to ment. For discussions on this subject see References discuss most of the priority scheduling procedures 1 and 2 and the bibliography of Reference 3. that have been considered in the past few years, to dis­ With a somewhat different orientation some of these cuss in a coherent way their effectiveness and weak­ topics have been covered elsewhere. In particular, Coffman,4 Greenberger5 and in more detail Estrin nesses in terms of the performance measures men­ 6 tioned above, to describe what the analysis of related and Kleinrock have reviewed the many applications queueing models has been able to provide in the way of queueing theory to the analysis of multiprogram­ of design aids, and in this last respect, to point out ming systems.
    [Show full text]
  • Scheduling Task-Parallel Programs in a Multiprogram Workload
    Scheduling Task-Parallel Programs in a Multiprogram Workload Karl Fenech Supervisors: Murray Cole Christian Fensch MSc Computer Science School of Informatics University of Edinburgh 2013 Abstract With commodity multicore architectures already prevalent, the microprocessor industry is poised to leap into the manycore era within the next few years. To avail of such machines’ multiprocessing capabilities, software developers are increasingly incentivized to parallelize their programs. This trend poses new challenges for the system scheduler, which will now need to consider the parallel characteristics of the respective programs when seeking to maximize the system-level performance of its multiprogram workloads. In this project, we reconcile two orthogonal approaches: work-stealing task-scheduling for efficiently unravelling structured parallelism from each program, and scalability-based processor-partitioning for dynamically optimizing the programs’ core allocations within the context of the current multiprogram workload on the manycore machine. We experimentally demonstrate that, for low- to moderate-scalability programs, our multiprogram scheduler can succeed in achieving modest improvements over mainstream thread and task schedulers. Keywords: parallel programming; structured parallelism; algorithmic skeletons; divide-and-conquer; manycore multiprocessing; multiprogram workloads; processor partitioning; scheduling; scalability; dynamic optimization i Acknowledgements My heartfelt gratitude goes to my supervisors, Dr Murray Cole and Dr Christian Fensch, who have been a steady source of insight, guidance, and support throughout the entirety of this project, from the inception of the idea, right up to their detailed feedback on the final drafts of this document. It is an enriching privilege to get the opportunity to work under the supervision of such accomplished individuals who still exhibit enthusiastic interest in your progress.
    [Show full text]
  • Static Multi-Tier Mapreduce Jobs Workflow Scheduling in Hybrid
    Static Multi-tier MapReduce Jobs Workflow Scheduling in Hybrid Clouds Hani Al-Sayeh TU Ilmenau, Germany [email protected] ABSTRACT can be represented as a workflow of tasks. To facilitate scien- Nowadays, huge data is being produced and needs to be ana- tific workflows deployment and hide infrastructure comple- lyzed to increase economic profits, improve civil services and xity during executing them, cloud computing is presented as achieve furthermore objectives. Processing Big Data requi- a cost-efficient computing infrastructure. There are several res multiple analysis stages represented as workflows of big types of clouds [1]: data jobs. In spite of the great evolution of big data pro- • Private clouds: Limited computational resources that cessing techniques, the lack of computing resources is one of users own and use to run their applications. the most significant challenges, that's why utilizing and ex- tending on demand these resources, using hybrid clouds, is • Public clouds: Huge collection of computational re- highly required. Good workflow scheduling approaches leads sources that users rent to run their applications. Theo- to better utilization of resources, reducing costs and meeting retically, these resources can be considered as unlimi- deadline constraints. To achieve this goal, we are proposing ted ones. an architecture of multi-tier MapReduce jobs workflow sche- duling in hybrid clouds with a basic cost model. • Hybrid clouds: A combination of both previous cloud types. Keywords Relying on MapReduce processing model and cloud com- MapReduce, Workflow scheduling, Hybrid clouds puting techniques, analyzing and extracting valuable infor- mation from big data sources within a feasible time is possi- 1.
    [Show full text]