1. Distributed (Operating) Systems -Processes and Threads-
Computer Engineering Department
Distributed Systems Course
Assoc. Prof. Dr. Ahmet Sayar
Kocaeli University - Fall 2015

2. Processes and Threads Processes management and their scheduling
Process: Executing context of a programme
Distributed Scheduling/migration
Can help in achieving scalability, but can also help to dynamically configure clients and servers
Multiprogramming versus multiprocessing
Multiprogramming: Ability to run more than one process on any machine
Multiple applications are running but only one may be executing in the core
Degree of multiprogramming determined by long term scheduling
Multiprocessing: You have more than one CPU core or processor in your machine, it enables multiple processors to run in parallel at the same time

3. Processes: Review Process is a program in execution
Kernel data structure: Process control block (PCB)
Keeps track of what the process keeps doing, when it started, where it resides, what files it has open, what sockets it has open
Each process has an address space
Contains code, global and local variables.
Processes have code and data segments carried out and in through pages
Process state transitions
When processes is created its state is new
When the process is load into memory its state is called ready
When processes is selected by CPU scheduler its state turns into run
When process makes a blocking IO its state turns into wait state
When process finish it turns into terminate state

4. Process States

5. Processes: Review Uniprocessor scheduling algorithms
Round-robin, shortest job first, FIFO, lottery scheduling*
CPU bound processes
IO bound processes
Performance metrics: Throughput, CPU utilization, turnaround time, response time, fairness
What is the difference between turnaround time and response time?

6. Context Switching
Switching the CPU between 2 processes – computationally expensive
CPU context
Register values, program counter, stack pointer, etc.
CPU and other hardware devices are shared by the processes.
OS keeps process table
Entries to store CPU register values, memory maps, open files, privileges, etc.
If OS supports more processes than it can simultaneously hold in main memory, it may have to swap processes between main memory and disk before the actual switch can take place.

7. Context Switching

8. Process Scheduling
Priority queues: Multiples queues, each with a different priority
Use strict priority scheduling
Example: Page swapper, kernel tasks, real-time tasks, user tasks
Multi-level feedback queue
Multiple queues with priority
Processes dynamically move from one queue to another
Depending on priority/CPU characteristics
Gives higher priority to I/O bound or interactive tasks
Lower priority to CPU bound tasks
Round robin at each level
Pre-emptive – Non-pre-emptive scheduling
FCFS is non-preemptive scheduling
Round-robin is preemptive scheduling

9. Example of processes and threads
Excel worksheet, client tool, browser all running together
Threads
In an excel worksheet; when a user changes the value in a single cell such a modification can trigger large series of computation. While excel is making those computations users can still enter other values continuously.

10. Processes and Threads Traditional process
One thread of control through a large, potentially sparse address space
Address space may be shared with other processes (shared memory)
Collection of systems resources (files, semaphores)
Thread (light weight process)
A flow of control through an address space
Each address space can have multiple concurrent control flows
Each thread has access to entire address space
Potentially parallel execution, minimal state (low overheads)
May need synchronization to control access to shared variables

11. Threads A process has many threads sharing its execution environment
Each thread has its own stack, PC, registers
Share address space, files,…

12. Why use Threads?
Large multiprocessors/multi-core systems need many computing entities (one per CPU or core )
Switching between processes incurs high overhead
With threads, an application can avoid per-process overheads
Thread creation, deletion, switching cheaper than processes
Threads have full access to address space (easy sharing)
Threads can execute in parallel on multiprocessors

13. Why Threads?
Single threaded process: Blocking system calls, no parallelism
1.The single thread processes (having one address space and one flow of control)
If there is blocking IO system whole process blocks (CPU waits idle -and put into IO queue ) until the IO finishes
Does not allow parallelism
2.One address space multiple processes
If one thread calls blocking IO, only that thread goes to IO queue, the other threads are still ready to run, so the CPU scheduler can actually chose process can continue to make progress.
CPU keeps running
3. Event-based (finite-state machine) model:
Also called asynchronous model
Allows you to get the parallelism with the single threaded processes
Instead of making blocking IO processes make non-blocking IO
You can send out IO instructions but instead of blocking keep doing what you are doing, when IO finishes you will basically get an exception on an event that you can go back and service the results of that IO
This is actually parallelizing IO and CPU job for a single process

14. Thread Management Creation and deletion of threads Critical sections
Static versus dynamic
Critical sections
Synchronization primitives: Blocking, spin-lock (busy-wait)
Condition variables
Global thread variables
Kernel versus user-level threads

15. User-level vs kernel threads
Key issues:
Cost of thread management
More efficient in user space
Ease of scheduling
Flexibility: Many parallel programming models and schedulers
Process blocking – a potential problem

16. User-level Threads Threads managed by a threads library Advantages:
Kernel is unaware of presence of threads
Advantages:
No kernel modifications needed to support threads
Efficient: creation/deletion/switches don’t need system calls
Flexibility in scheduling: library can use different scheduling algorithms, can be application dependent
Disadvantages
Need to avoid blocking system calls [all threads block]
Threads compete for one another
Does not take advantage of multiprocessors [no real parallelism]
Blocking system calls block the whole process

17. Kernel-level threads Kernel aware of the presence of threads
Better scheduling decisions, more expensive
Better for multiprocessors, more overheads for uniprocessors
Blocking system calls done by a process is no problem
Loss of efficiency (all operations are performed as system calls)
Conclusion: Try to mix user-level and kernel-level threads into a single concept

18. Light-weight Processes (Hybrid Approach)
Combining kernel-level lightweight processes and user-level threads

19. Light-weight Processes (LWP)
Several LWPs per heavy-weight process
User-level threads package
Create/destroy threads and synchronization primitives
Multithreaded applications – create multiple threads, assign threads to LWPs (one-one, many-one, many-many)
When a thread calls a blocking user-level operation (e.g. block on a mutex or a condition variable), and another runnable thread is found, a context switch is made to that thread which is then bound to the same LWP
When a thread does a blocking system-level call, its LWP blocks. The thread remains bound to the LWP. The kernel schedules another LWP having a runnable thread bound to it. This also implies that a context switch is made back to user mode. The selected LWP will simply continue where it had previously had left off.

20. Thread Packages Posix Threads (pthreads) Java Threads
Widely used threads package
Conforms to the Posix standard
Sample calls: pthread_create,…
Typical used in C/C++ applications
Can be implemented as user-level or kernel-level or via LWPs
Java Threads
Native thread support built into the language
Threads are scheduled by the JVM

21. Quiz
At any specific time, how many threads can be running in the system?
Is the question correct?
Correct the question and answer it.
What does a thread need when it is created?
Lets assume there is a sequential process that cannot be divided into parallel task. Do you think it can utilize threads?
Process is doing IO instruction and context switch occurs?
Process is doing CPU instruction and context switch occurs?

22. Threads in Distributed Systems
Threads allow clients and servers to be constructed such that communication and local processing can overlap, resulting in a high-level performance.
They can provide a convenient means of allowing blocking system calls without blocking the entire process in which the thread is running
The main idea is to exploit parallelism to attain high performance (especially when executing a program on a multiprocessor system).
Multithreaded Clients
Multithreaded Servers

23. Multi-threaded Clients Example
Main issue is hiding network latency
Browsers such as IE are multi-threaded
Such browsers can display data before entire document is downloaded: performs multiple simultaneous tasks
Fetch main HTML page, activate separate threads for other parts
Each thread sets up a separate connection with the server
Uses blocking calls
Each part (gif image) fetched separately and in parallel
Advantage: connections can be setup to different sources
Ad server, image server, web server…

24. Multi-threaded Server Example
Main issue is improved performance and better structure
Apache web server: Pool of pre-spawned worker threads
Dispatcher thread waits for requests
For each request, choose an idle worker thread
Worker thread uses blocking system calls to service web request

25. Three ways to construct a server
Threads
Parallelism, blocking system call
Single-threaded process
No parallelism, blocking system call.
How it runs? Lets say file server…
Finite-state machine
Single thread but imitating parallelism, non-blocking system calls