process management(thread scheduling)

7/30/2019 Process Management(Thread Scheduling)

1/21

THREADS


2/21

Single and Multithreaded Processes

A thread is a fundamental unit of CPU utilization that forms the basis of

multithreaded computer systems


3/21

Benefits

Responsiveness

Resource Sharing

Economy

Utilization of MP Architectures


4/21

Multithreaded Server Architecture

This architecture is not expensive as creation & switching amongst processes

is costly


5/21

User & Kernel Threads

User Threads: Thread management done by user-level threads library

Three primary thread libraries:

Java threads

Kernel Threads; Supported by the Kernel

Examples Windows XP/2000

Solaris

Linux


6/21

Threads vs. Processes

Both threads and processes are methods of parallelizing an application.

However, processes are independent execution units that contain their own

state information, use their own address spaces, and only interact with each

other via interprocess communication mechanisms.

A single process might contains multiple threads; all threads within a process

share the same state and same memory space, and can communicate with

each other directly, because they share the same variables.

Applications are typically divided into processes during the design phase,.

Processes, in other words, are an architectural construct.By contrast, a thread is a coding construct that doesn't affect the architecture

of an application.


7/21

Advantages of Thread

A process with multiple threads make a great server for example printer server.

Because threads can share common data, they do not need to use interprocess communication.Because of the very nature, threads can take advantage of multiprocessors.

Threads are economical in the sense that:

They only need a stack and storage for registers therefore, threads are cheap to

create.

Threads use very little resources of an operating system in which they are

working. That is, threads do not need new address space

Context switching are fast when working with threads. The reason is that we only

have to save and/or restore PC, SP and registers.

But this cheapness does not come free - the biggest drawback is that there is noprotection between threads.


8/21

User Level Threads

User-level threads implement in user-level libraries, rather than via systems calls, so thread switching

does not need to call operating system and to cause interrupt to the kernel. In fact, the kernel knows

nothing about user-level threads and manages them as if they were single-threaded processes.

Advantages:

The most obvious advantage of this technique is that a user-level threads package can be

implemented on an Operating System that does not support threads.

User-level threads does not require modification to operating systems.

Simple Management: This simply means that creating a thread, switching between threads and

synchronization between threads can all be done without intervention of the kernel.

Disadvantages:

There is a lack of coordination between threads and operating system kernel. Therefore,

process as 0whole gets one time slice irrespect of whether process has one thread or 1000

threads within.

User-level threads requires non-blocking systems call i.e., a multithreaded kernel. Otherwise,

entire process will blocked in the kernel, even if there are runable threads left in the processes.

For example, if one thread causes a page fault, the process blocks.


9/21

Kernel-Level Threads

In this method, the kernel knows about and manages the threads.

Advantages:

Because kernel has full knowledge of all threads, Scheduler may decide to give

more time to a process having large number of threads than process having small

number of threads.

Kernel-level threads are especially good for applications that frequently block.

Disadvantages:

The kernel-level threads are slow and inefficient. For instance, threads operations

are hundreds of times slower than that of user-level threads.


10/21

Advantages of Threads over Multiple Processes

Context Switching Threads are very inexpensive to create and destroy. For example, they

require space to store, the PC, the SP, and the general-purpose registers, but they do not

require space to share memory information, Information about open files of I/O devices in

use, etc. With so little context, it is much faster to switch between threads. In other words, it is

relatively easier for a context switch using threads.

Sharing Treads allow the sharing of a lot resources that cannot be shared in process, for

example, sharing code section, data section, Operating System resources like open file etc.

Disadvantages of Threads over Multiprocesses

Blocking The major disadvantage if that if the kernel is single threaded, a system call of

one thread will block the whole process and CPU may be idle during the blocking period.

Security Since there is, an extensive sharing among threads there is a potential problem ofsecurity. It is quite possible that one thread over writes the stack of another thread (or

damaged shared data) although it is very unlikely since threads are meant to cooperate on a

single task.


11/21

Application that Benefits from Threads

A proxy server satisfying the requests for a number of computers on a LAN would be benefitedby a multi-threaded process. In general, any program that has to do more than one task at a time

could benefit from multitasking. For example, a program that reads input, process it, and

outputs could have three threads, one for each task.

Application that cannot Benefit from Threads

Any sequential process that cannot be divided into parallel task will not benefit from thread, as

they would block until the previous one completes. For example, a program that displays the

time of the day would not benefit from multiple threads.


12/21

Synchronization


13/21

Background

Concurrent access to shared data may result indata inconsistency (e.g., due to race conditions)

Maintaining data consistency requires

mechanisms to ensure the orderly execution of

cooperating processes Suppose that we wanted to provide a solution to

the consumer-producer problem that fills allthe

buffers.

We can do so by having an integer count that keepstrack of the number of full buffers.

Initially, count is set to 0.

Incremented by producer after producing a new

buffer

Decremented by consumer after consuming a buffer


14/21

A race condition occurs when multiple processes access and

manipulate the same data concurrently, and the outcome of the

execution depends on the particular order in which the access

takes


15/21

A section of code, common to n cooperating processes, in which

the processes may be accessing common

variables.

A Critical Section Environment contains:

Entry Section Code requesting entry into the critical section.

Critical Section Code in which only one process can execute at any

one time.

Exit Section The end of the critical section, releasing or allowingothers in.

Remainder Section Rest of the code AFTER the critical section.

Critical Sections


16/21

Solution to Critical-Section Problem

Software

Peterson's Algorithm: based on busy waiting

Semaphores: general facility provided by operating system

(e.g., OS/2)

based on low-level techniques such as busy waiting or hardware

assistance

described in more detail below

Monitors: programming language technique. Key Idea: Only

one process may be active within the monitor at a time

Hardware

Test-and-Set: atomic machine-level instruction

In computer science, the test-and-set instruction is an instructionused to write to a memory location and return its old value as a

single atomic (i.e. non-interruptible) operation. If multiple

processes may access the same memory, and if a process is

currently performing a test-and-set, no other process may begin

another test-and-set until the first process is done

Swap: atomically swaps contents of two words


17/21

Peterson's Algorithm

a simple algorithm that can be run by two processes to ensure mutualexclusion for one resource (say one variable or data structure)

does not require any special hardware it uses busy waiting (a spinlock)

Semaphore

a variable used for signalling between processes

two main operations on semaphore are:

Wait for next process (or acquire) Signal to other process (or release)

A resource such as a shared data structure is protected by asemaphore. You must acquire the semaphore before using theresource.


18/21

Deadlock and Starvation

Deadlock two or more processes are waiting indefinitely for anevent that can be caused by only one of the waiting processes

Let S and Q be two semaphores initialized to 1

P0 P1wait (S); wait (Q);

wait (Q); wait (S);

. .

. .

. .

signal (S); signal (Q);

signal (Q); signal (S);

Starvation indefinite blocking. A process may never beremoved from the semaphore queue in which it is suspended.


19/21

Bounded Buffer problem

Producer

creates data and adds to the buffer

do not want to overflow the buffer

Consumer

removes data from buffer (consumes it) do not want to get ahead of producer


20/21

Reader & Writer

data set is shared among a number of concurrent processes

Readers only read the data set; do not perform any updates

Writers can both read and write.

Problem

Allow multiple readers to read at the same time.

Only one writer can access the shared data at the same time.


21/21

Dining-Philosophers Problem

The dining philosophers problem is summarized as five philosophers

sitting at a table doing one of two things: eating or thinking. While

eating, they are not thinking, and while thinking, they are not eating.

The five philosophers sit at a circular table with a large bowl of

spaghetti in the center. A fork is placed in between each pair of

adjacent philosophers, and as such, each philosopher has one fork to

his left and one fork to his right. As spaghetti is difficult to serve and

eat with a single fork, it is assumed that a philosopher must eat with

two forks. Each philosopher can only use the forks on his immediate

left and immediate right.

Shared data

Bowl of rice (data set)

Semaphore chopstick [5] initialized to 1

process management(thread scheduling)

Documents