1. Understanding Operating Systems Sixth Edition
Chapter 6 Concurrent Processes

2. Learning Objectives
After completing this chapter, you should be able to describe:
The critical difference between processes and processors, and their connection
The differences among common configurations of multiprocessing systems
The significance of a critical region in process synchronization
The basic concepts of process synchronization software: test-and-set, WAIT and SIGNAL, and semaphores
Understanding Operating Systems, Sixth Edition

3. Learning Objectives (cont'd.)
The need for process cooperation when several processes work together
How several processors, executing a single job, cooperate
The similarities and differences between processes and threads
The significance of concurrent programming languages and their applications
Understanding Operating Systems, Sixth Edition

4. What Is Parallel Processing?
Multiprocessing
Two or more processors operate in unison
Two or more CPUs execute instructions simultaneously
Processor Manager
Coordinates activity of each processor
Synchronizes interaction among CPUs
Understanding Operating Systems, Sixth Edition

5. What Is Parallel Processing? (cont'd.)
Parallel processing development
Enhances throughput
Increases computing power
Benefits
Increased reliability
More than one CPU
If one processor fails, others take over
Not simple to implement
Faster processing
Instructions processed in parallel two or more at a time
Understanding Operating Systems, Sixth Edition

6. What Is Parallel Processing? (cont'd.)
Faster instruction processing methods
CPU allocated to each program or job
CPU allocated to each working set or parts of it
Individual instructions subdivided
Each subdivision processed simultaneously
Concurrent programming
Two major challenges
Connecting processors into configurations
Orchestrating processor interaction
Example: six-step information retrieval system
Synchronization is key
Understanding Operating Systems, Sixth Edition

7. What Is Parallel Processing? (cont'd.)
Understanding Operating Systems, Sixth Edition

8. Evolution of Multiprocessors
Developed for high-end midrange and mainframe computers
Each additional CPU treated as additional resource
Today hardware costs reduced
Multiprocessor systems available on all systems
Multiprocessing occurs at three levels
Job level
Process level
Thread level
Each requires different synchronization frequency
Understanding Operating Systems, Sixth Edition

9. Evolution of Multiprocessors (cont'd.)
Understanding Operating Systems, Sixth Edition

10. Introduction to Multi-Core Processors
Multi-core processing
Several processors placed on single chip
Problems
Heat and current leakage (tunneling)
Solution
Single chip with two processor cores in same space
Allows two sets of simultaneous calculations
80 or more cores on single chip
Two cores each run more slowly than single core chip
Understanding Operating Systems, Sixth Edition

11. Typical Multiprocessing Configurations
Multiple processor configuration impacts systems
Three types
Master/slave
Loosely coupled
Symmetric
Understanding Operating Systems, Sixth Edition

12. Master/Slave Configuration
Asymmetric multiprocessing system
Single-processor system
Additional slave processors
Each managed by primary master processor
Master processor responsibilities
Manages entire system
Maintains all processor status
Performs storage management activities
Schedules work for other processors
Executes all control programs
Understanding Operating Systems, Sixth Edition

13. Master/Slave Configuration (cont'd.)
Understanding Operating Systems, Sixth Edition

14. Master/Slave Configuration (cont'd.)
Advantages
Simplicity
Disadvantages
Reliability
No higher than single processor system
Potentially poor resources usage
Increases number of interrupts
Understanding Operating Systems, Sixth Edition

15. Loosely Coupled Configuration
Several complete computer systems
Each with own resources
Maintains commands and I/O management tables
Independent single-processing difference
Each processor
Communicates and cooperates with others
Has global tables
Several requirements and policies for job scheduling
Single processor failure
Others continue work independently
Difficult to detect
Understanding Operating Systems, Sixth Edition

16. Loosely Coupled Configuration (cont'd.)
Understanding Operating Systems, Sixth Edition

17. Symmetric Configuration
Decentralized processor scheduling
Each processor is same type
Advantages (over loosely coupled configuration)
More reliable
Uses resources effectively
Can balance loads well
Can degrade gracefully in failure situation
Most difficult to implement
Requires well synchronized processes
Avoids races and deadlocks
Understanding Operating Systems, Sixth Edition

18. Symmetric Configuration (cont'd.)
Understanding Operating Systems, Sixth Edition

19. Symmetric Configuration (cont'd.)
Decentralized process scheduling
Single operating system copy
Global table listing
Interrupt processing
Update corresponding process list
Run another process
More conflicts
Several processors access same resource at same time
Process synchronization
Algorithms resolving conflicts between processors
Understanding Operating Systems, Sixth Edition

20. Process Synchronization Software
Successful process synchronization
Lock up used resource
Protect from other processes until released
Only when resource is released
Waiting process is allowed to use resource
Mistakes in synchronization can result in:
Starvation
Leave job waiting indefinitely
Deadlock
If key resource is being used
Understanding Operating Systems, Sixth Edition

21. Process Synchronization Software (cont'd.)
Critical region
Part of a program
Critical region must complete execution
Other processes must wait before accessing critical region resources
Processes within critical region
Cannot be interleaved
Threatens integrity of operation
Understanding Operating Systems, Sixth Edition

22. Process Synchronization Software (cont'd.)
Implemented as lock-and-key arrangement:
Process determines key availability
Process obtains key
Puts key in lock
Makes it unavailable to other processes
Types of locking mechanisms
Test-and-set
WAIT and SIGNAL
Semaphores
Understanding Operating Systems, Sixth Edition

23. Test-and-Set Indivisible machine instruction
Executed in single machine cycle
If key available: set to unavailable
Actual key
Single bit in storage location: zero (free) or one (busy)
Before process enters critical region
Tests condition code using TS instruction
No other process in region
Process proceeds
Condition code changed from zero to one
P1 exits: code reset to zero, allowing others to enter
Understanding Operating Systems, Sixth Edition

24. Test-and-Set (cont'd.) Advantages Drawbacks
Simple procedure to implement
Works well for small number of processes
Drawbacks
Starvation
Many processes waiting to enter a critical region
Processes gain access in arbitrary fashion
Busy waiting
Waiting processes remain in unproductive, resource-consuming wait loops
Understanding Operating Systems, Sixth Edition

25. WAIT and SIGNAL Modification of test-and-set
Designed to remove busy waiting
Two new mutually exclusive operations
WAIT and SIGNAL
Part of process scheduler’s operations
WAIT
Activated when process encounters busy condition code
SIGNAL
Activated when process exits critical region and condition code set to “free”
Understanding Operating Systems, Sixth Edition

26. Semaphores Nonnegative integer variable Two operations of semaphore
Flag
Signals if and when resource is free
Resource can be used by a process
Two operations of semaphore
P (proberen means “to test”)
V (verhogen means “to increment”)
Understanding Operating Systems, Sixth Edition

27. Semaphores (cont'd.)
Understanding Operating Systems, Sixth Edition

28. Semaphores (cont'd.) Let s be a semaphore variable
V(s): s: = s + 1
Fetch, increment, store sequence
P(s): If s > 0, then s: = s – 1
Test, fetch, decrement, store sequence
s = 0 implies busy critical region
Process calling on P operation must wait until s > 0
Waiting job of choice processed next
Depends on process scheduler algorithm
Understanding Operating Systems, Sixth Edition

29. Semaphores (cont'd.)
Understanding Operating Systems, Sixth Edition

30. Semaphores (cont'd.) P and V operations on semaphore s
Enforce mutual exclusion concept
Semaphore called mutex (MUTual EXclusion)
P(mutex): if mutex > 0 then mutex: = mutex – 1
V(mutex): mutex: = mutex + 1
Critical region
Ensures parallel processes modify shared data only while in critical region
Parallel computations
Mutual exclusion explicitly stated and maintained
Understanding Operating Systems, Sixth Edition

31. Process Cooperation
Several processes work together to complete common task
Each case requires
Mutual exclusion and synchronization
Absence of mutual exclusion and synchronization
Results in problems
Examples
Producers and consumers problem
Readers and writers problem
Each case implemented using semaphores
Understanding Operating Systems, Sixth Edition

32. Producers and Consumers
One process produces data
Another process later consumes data
Example: CPU and line printer buffer
Delay producer: buffer full
Delay consumer: buffer empty
Implemented by two semaphores
Number of full positions
Number of empty positions
Mutex
Third semaphore: ensures mutual exclusion
Understanding Operating Systems, Sixth Edition

33. Producers and Consumers (cont'd.)
Understanding Operating Systems, Sixth Edition

34. Producers and Consumers (cont'd.)
Understanding Operating Systems, Sixth Edition

35. Producers and Consumers (cont'd.)
Understanding Operating Systems, Sixth Edition

36. Producers and Consumers (cont'd.)
Producers and Consumers Algorithm
empty: = n
full: = 0
mutex: = 1
COBEGIN
repeat until no more data PRODUCER
repeat until buffer is empty CONSUMER
COEND
Understanding Operating Systems, Sixth Edition

37. Readers and Writers Two process types need to access shared resource
Example: file or database
Example: airline reservation system
Implemented using two semaphores
Ensures mutual exclusion between readers and writers
Resource given to all readers
Provided no writers are processing (W2 = 0)
Resource given to a writer
Provided no readers are reading (R2 = 0) and no writers writing (W2 = 0)
Understanding Operating Systems, Sixth Edition

38. Concurrent Programming
Concurrent processing system
One job uses several processors
Executes sets of instructions in parallel
Requires programming language and computer system support
Understanding Operating Systems, Sixth Edition

39. Applications of Concurrent Programming
A = 3 * B * C + 4 / (D + E) ** (F – G)
Understanding Operating Systems, Sixth Edition

40. Applications of Concurrent Programming (cont'd.)
A = 3 * B * C + 4 / (D + E) ** (F – G)
Understanding Operating Systems, Sixth Edition

41. Applications of Concurrent Programming (cont'd.)
Explicit parallelism
Requires programmer intervention
Explicitly state parallel executable instructions
Disadvantages
Time-consuming coding
Missed opportunities for parallel processing
Errors
Parallel processing mistakenly indicated
Programs difficult to modify
Understanding Operating Systems, Sixth Edition

42. Applications of Concurrent Programming (cont'd.)
Implicit parallelism
Compiler automatically detects parallel instructions
Advantages
Solves explicit parallelism problems
Complexity dramatically reduced
Working with array operations within loops
Performing matrix multiplication
Conducting parallel searches in databases
Sorting or merging file
Understanding Operating Systems, Sixth Edition

43. Threads and Concurrent Programming
Small unit within process
Scheduled and executed
Minimizes overhead
Swapping process between main memory and secondary storage
Each active process thread
Processor registers, program counter, stack and status
Shares data area and resources allocated to its process
Understanding Operating Systems, Sixth Edition

44. Thread States
Understanding Operating Systems, Sixth Edition

45. Thread States (cont'd.) Operating system support Creating new threads
Setting up thread
Ready to execute
Delaying or putting threads to sleep
Specified amount of time
Blocking or suspending threads
Those waiting for I/O completion
Setting threads to WAIT state
Until specific event occurs
Understanding Operating Systems, Sixth Edition

46. Thread States (cont'd.) Operating system support (cont'd.)
Scheduling thread execution
Synchronizing thread execution
Using semaphores, events, or conditional variables
Terminating thread
Releasing its resources
Understanding Operating Systems, Sixth Edition

47. Thread Control Block
Information about current status and characteristics of thread
Understanding Operating Systems, Sixth Edition

48. Concurrent Programming Languages
Ada
First language providing specific concurrency commands
Developed in late 1970’s
Java
Designed as universal Internet application software platform
Developed by Sun Microsystems
Adopted in commercial and educational environments
Understanding Operating Systems, Sixth Edition

49. Java
Allows programmers to code applications that can run on any computer
Developed at Sun Microsystems, Inc. (1995)
Solves several issues
High software development costs for different incompatible computer architectures
Distributed client-server environment needs
Internet and World Wide Web growth
Uses compiler and interpreter
Easy to distribute
Understanding Operating Systems, Sixth Edition

50. Java (cont'd.) The Java Platform Software only platform Two components
Runs on top of other hardware-based platforms
Two components
Java Virtual Machine (Java VM)
Foundation for Java platform
Contains the interpreter
Runs compiled bytecodes
Java application programming interface (Java API)
Collection of software modules
Grouped into libraries by classes and interfaces
Understanding Operating Systems, Sixth Edition

51. Java (cont'd.)
Understanding Operating Systems, Sixth Edition

52. Java (cont'd.) The Java Language Environment
Designed for experienced programmers (like C++)
Object oriented
Exploits modern software development methods
Fits into distributed client-server applications
Memory allocation features
Done at run time
References memory via symbolic “handles”
Translated to real memory addresses at run time
Not visible to programmers
Understanding Operating Systems, Sixth Edition

53. Java (cont'd.) Security Sophisticated synchronization capabilities
Built-in feature
Language and run-time system
Checking
Compile-time and run-time
Sophisticated synchronization capabilities
Multithreading at language level
Popular features
Handles many applications; can write a program once; robust; Internet and Web integration
Understanding Operating Systems, Sixth Edition

54. Summary Multiprocessing Single-processor systems
Interacting processes obtain control of CPU at different times
Systems with two or more CPUs
Control synchronized by processor manager
Processor communication and cooperation
System configuration
Master/slave, loosely coupled, symmetric
Understanding Operating Systems, Sixth Edition

55. Summary (cont'd.) Multiprocessing system success Mutual exclusion
Synchronization of resources
Mutual exclusion
Prevents deadlock
Maintained with test-and-set, WAIT and SIGNAL, and semaphores (P, V, and mutex)
Synchronize processes using hardware and software mechanisms
Understanding Operating Systems, Sixth Edition

56. Summary (cont'd.) Avoid typical problems of synchronization
Missed waiting customers
Synchronization of producers and consumers
Mutual exclusion of readers and writers
Concurrent processing innovations
Threads and multi-core processors
Requires modifications to operating systems
Understanding Operating Systems, Sixth Edition