Os Exam 2

Front 1

Thread

Back 1

Basic unit of utilization

Front 2

What does a thread contain?

Back 2

stack

thread Id

program counter

register set

Front 3

What do threads belonging to the same process share?

Back 3

Code Section

Data Section

Other OS resources (such as open files and signals)

Front 4

What is a thread library?

Back 4

Provides the programmer with an API for creating and managing threads.

Front 5

Three main thread libraries in use today?

Back 5

POSIX Pthreads

Win32

Java

Front 6

What manages java threads?

Back 6

JVM

Front 7

Java threads can be created by:

Back 7

Extends Thread class and overwrites its run() function

Implementing the Runnable interface

Front 8

Thread Cancellation
Asynchronous Cancellation

Back 8

Terminates target thread immediately

Front 9

Thread Cancellation

Deferred Cancellation

Back 9

Allows the target thread to periodically check if it should be canceled.

Front 10

What are Thread Pools?

Back 10

Creating a number of threads in a pool where they await work.

Front 11

Thread Pools Advantage

Back 11

Usually slightly faster to service a request with an existing thread than creating a new thread.

Allows the number of threads in the application(s) to be bound to the size of the pool.

Front 12

CPU - I/O Burst Cycle

Back 12

Process execution consists of a cycle of CPU execution and I/O wait

Front 13

How many CPU burst cycles does an I/O program usually have?

Back 13

Many short bursts

Front 14

How many CPU burst cycles does a CPU bound program have?

Back 14

Few long burst cycles

Front 15

CPU scheduler decisions take place when a process:

Back 15

Switches from running to waiting state.
Switches from running to ready state.
Switches from waiting to ready state.
Terminates

Front 16

Which two states are preemptive?

Switches from running to waiting state.
Switches from running to ready state.
Switches from waiting to ready state.
Terminates

Back 16

Switches from running to ready state.

Switches from waiting to ready state.

Front 17

Which two states are preemptive?

Switches from running to waiting state.

Switches from running to ready state.

Switches from waiting to ready state.

Terminates

Back 17

Switches from running to waiting state.

Terminates

Front 18

Dispatcher module

Back 18

Gives control of the CPU to the process selected by the short-term scheduler.

Front 19

Scheduling Criteria

CPU utilization

Back 19

Keep the CPU as busy as possible

Front 20

Scheduling Criteria

Throughput

Back 20

# of processes that complete their execution per time unit

Front 21

Scheduling Criteria

Turnaround time

Back 21

Amount of time to execute a particular process

Front 22

Scheduling Criteria

Waiting time

Back 22

Amount of time a process has been waiting in the ready queue

Front 23

Scheduling Criteria

Response Time

Back 23

Amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment)

Front 24

Multiple-Processor Scheduling

Two types

Back 24

Asymmetric multiprocessing

Symmetric mmultiprocessing (SMP)

Front 25

Multiple-Processor Scheduling

Two types of Affinitity

Back 25

Soft affinity - not guaranteed

Hard affinity - Guarantreed ex. Linux

Front 26

Multiple-Processor Scheduling

Load Balancing

Back 26

Keep the processor workload evenly distrbuted among processors.

Front 27

Multiple-Processor Scheduling

Two types of migration

Back 27

Push - specific task periodically checks

Pull - idle processor will pull a waiting task from a busy processor

Front 28

Multiple-Processor Scheduling

Processor affinity

Back 28

Cache memory populated with data accessed recently by the process in execution; if to switch processor, needs ot invalidate the first chache memory and repopulate the second cache.

Avoid this

Front 29

Real-Time Scheduling

Two types

Back 29

Hard real-time systems

Soft real-time systems

Front 30

Solaris Dispatch Table for scheduling interactive and time-sharing threads60 Priority levels (0~59)

Back 30

Priority: Higher number indicates higher priority Time quantum: Lowest priority has the highest time quantum

Front 31

Windows Priorities

Back 31

Priority-based, preemptive scheduling algorithm

Uses 32-level (0~31) scheme to determine the order of thread execution, higher number indicates higher priority.

Front 32

Linux Scheduling

Back 32

- Priority-based, preemptive

- Lower value indicates higher priority (different from Solaris and Windows)

- Linux assigns higher priority tasks longer time quanta and lower-priority tasks shorter time quanta

Front 33

Process Synchronization

Background

Back 33

Concurrent access to shared data may result in data inconcistency.

Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes

Front 34

Critical-section Problem

3 requirements

Back 34

1. Mutual Exclusion

2. Progress

3. Bounded Waiting

Front 35

Peterson's Solution

Two process solution

Back 35

Assume that load and store instructions are atomic (uninterruptable)

The two processes share two variables:

int turn;

Boolean flag[2];

Front 36

Synchonization Hardware

Back 36

Modern machines provide special atomic hardware instructions.

Either test memory word and set value

Or swap contents of two memory words

Front 37

Semaphore

Hardware issue

Synchronization advantage

Semaphore S variable type

Back 37

Hardware - hard for application programmers to use

Syn. tool doesn't require busy waiting

Semaphore type - Integer

Front 38

Semaphore

S modifiers

Synchronization hardware

Counting Semaphore

Binary Semaphore

Back 38

Operations: acquire() and release()GetAndSet and Swap

Counting semaphore (Range over an unrestricted domain)

Binary Semaphore ( 0 or 1)

Front 39

Semaphore Implementation

Guarantee

Back 39

No two processes can execute acquire() and release() on the same semaphore at the same time

Front 40

Semaphore Implementation

Critical section problem

Back 40

Implementation, Wait and signal code placed in critical section

Busy waiting in critical section in implementation

Implementation code is short

Little busy waiting if critical section rarely occupied.

Front 41

Semaphore Implementation

Why is this a bad solution

Back 41

Applications may spent a lot of time in critical sections.

Front 42

Semaphore Implementation with no Busy waiting

Waiting queue data types (2)

Back 42

Value (of type integer)

pointer to next record in the list

Front 43

Semaphore Implementation with no Busy waiting

Two operations

Back 43

Block

Wakeup

Front 44

Deadlock

Starvation

Back 44

sdf

Front 45

Monitors

Back 45

A high-level abstraction that provides a convenient and effective mechanism for process synchronization

Only one process may be active within the monitor at a time

Front 46

Condition variables

x.wait()

x.signal()

Back 46

wait() - process that invokes the operation is suspended

signal() - Resumes one of the processes (if any) that invoked x.wait()

Front 47

See and add stuff from slides

Back 47

slides