1. Chapter 3 Process Concepts
Overview
Process Scheduling
Operations on Processes
Interprocess Communication
Examples of IPC Systems
Communication in Client-Server Systems

2. OS executes a variety of programs
3.1 Overview
OS executes a variety of programs
Batch system –– jobs
Time-shared systems –– user programs or tasks
We use the terms job and process almost interchangeably
Process – a program in execution
Process execution must progress sequentially
A process includes
Program counter and the processor’s registers
Stack (temporary data, method parameters, return address, local variables)
Data section (contains global variables)
Heap — memory dynamically allocated during process run time

3. 3.1 Overview
Processes associated with the same program are considered separate execution sequences
Several users may be running the copies of the mail program
The same user may invoke many copies of the editor program
Each of these is a separate process, and, although the text sections (program codes) are equivalent, the data section will vary
A process may spawn (繁衍) many processes as it runs
例：網頁瀏覽器中「新增」另一新視窗

5. 3.1 Overview: Process State
As a process executes, it changes state
new: The process is being created
running: Instructions are being executed
waiting (blocked): The process is waiting for some event to occur (e.g. I/O completion or reception of a signal)
ready: waiting to be assigned to a processor
terminated: The process has finished execution

6. 3.1 Overview: Process Control Block
… 或稱為Task Control Block
Each process is represented by a process control block (PCB)
Process state: N, R, T, W, Run
Program counter
CPU registers
CPU scheduling information
Process priority, pointers to scheduling queues, and any other scheduling parameters
Memory-management information
Accounting information
I/O status information …

7. Figure 3.4: CPU Switch from Process to Process

8. A single-processor system can have only one running process
3.2 Process Scheduling
Multiprogramming has some process running at all times, to maximize CPU utilization
The objective of time sharing is to switch the CPU among the processes so frequently that users can interact with each program while it is running
A single-processor system can have only one running process
The rest waits until CPU is free and is rescheduled
Process scheduling (排程) is required

9. Process Representation in Linux
Represented by the C structure task_struct pid_t pid; /* process identifier */ long state; /* state of the process */ struct sched_entity se; /* scheduling information */ struct task_struct *parent; /* this process’s parent */ struct list_head children; /* this process’s children */ struct files_struct *files; /* list of open files */ struct mm_struct *mm; /* address space of this process */

10. 3.2 Process Scheduling: Scheduling Queues
Job queue
Consists of all processes in the system
Ready queue
Keeps processes that are residing in main memory and are ready and waiting to execute
Device queue
List of processes waiting for a particular I/O device
Each device has its own device queue

11. Ready Queue and Various I/O Device Queues

12. Queueing Diagram of Process Scheduling
Resources
Queues
Parent may wait for its termination
Processes migrate between various queues

13. 3.2 Process Scheduling: Schedulers
A process migrates between the various scheduling queues throughout its lifetime
Process selection is carried out by the appropriate scheduler
Long-term, short-term, mid-term
Long-term scheduler (job scheduler)
Selects processes from process pool and loads them into memory (ready queue)
Controls the degree of multiprogramming, i.e., number of processes in memory
Should select a good process mix of I/O-bound and CPU-bound processes

14. 3.2 Process Scheduling: Schedulers
Short-term scheduler (CPU scheduler)
Selects one of the ready processes and allocates the CPU to it
Medium-term scheduler
Removes processes from memory and reduces the degree of multiprogramming

15. 3.2 Process Scheduling: Schedulers
Short-term and long-term schedulers differ mainly in the frequency of their execution
Short-term scheduler is invoked very frequently (milliseconds)  must be fast
Long-term scheduler is invoked infrequently (seconds, minutes)  may be slow
Processes can be described as either:
I/O-bound process: spends more time doing I/O than computations; many short CPU bursts
CPU-bound process: spends more time doing computations; few very long CPU bursts

16. 3.2 Process Scheduling: Context Switch
例：圖書館書桌由大家共用，每個人有獨特的文具擺設需求，使用書桌前令其恢復習慣的樣貌
Switching CPU to another process requires saving the state of the old process and loading the saved state for the new process
This task is known as a context switch
Context-switch time is pure overhead
The system does no useful work while switching
1~1000μs
Dependent on hardware support
Some processors provide multiple sets of registers; a context switch simply includes changing the pointer to the current register set
Memory management, address space of current processes

17. 3.3 Operations on Processes
Processes can execute concurrently, and must be created/deleted dynamically
Process creation
Parent process create children processes, which in turn create other processes  a tree of processes

18. 3.3 Operations on Processes: Process Creation
Resource sharing
Parent and children share all resources
Children share subset of parent’s resources
Parent and child share no resources
Execution
Parent and children execute concurrently
Parent waits until children terminate
Address space
Child duplicate of parent
Child has a program loaded into it

19. 3.3 Operations on Processes: Process Creation
UNIX examples
fork creates a new process
exec system call after fork replaces the process’ memory space with a new program
execlp loads a binary file into memory

20. fork()猶如火影忍者鳴人常用的招術

23. Process Creation*: UNIX Process Address Space
Three regions of memory
A read-only text region (executable code)
A read-write region consisting of initialized data, uninitialized data, dynamic area
This region is often collectively called the data region
A 2nd read-write region containing the process’ user stack
This region grows implicitly
Per-process limits on the maximum data and stack sizes of processes
text
data
Uninitialized data
dynamic
stack

24. Process Creation*: Before and After fork()
child process (pid = p)
fork( ) //return 0
By executing fork the parent process creates a clone of itself
One thread of control flows into fork() but two threads of control flow out, each in a separate address space
From the parent’s point of view, nothing happens except that fork() returns the process ID of the new process
New process starts off life by returning from fork. It always views fork as returning a zero
複製完整的 address space
fork( ) //return p
parent process

25. Process Creation*: exec() Loads a New Image
Child process (after)
prog’s text
prog’s data
args for prog
The purpose of creating a new process is mostly to run a new, different program
Once a new process has been created, the exec system call can be used to load a new program image into itself, replacing the prior contents of the process’s address space
exec(prog, args)
Child process (before)

26. A Stripped-Down Shell* (以UNIX為例)
while (TRUE) { /* repeat forever */
type_prompt( ); /* display prompt */
read_command (command, parameters); /* input from terminal */
if (fork() != 0) { /* fork off child process */
/* Parent code */
waitpid(-1, &status, 0); /* wait for child to exit */ }
else {
/* Child code */
execve (command, parameters, 0); /* execute command */

27. Creating a Separate Process via Windows API

28. 4.3 Operations on Processes: Process Termination
Process executes its final statement and asks the operating system to delete it (exit)
Output data from child to parent (via wait)
Process’ resources deallocated by the OS
Parent may terminate execution of children processes (abort)
Child has exceeded allocated resources
Task assigned to the child is no longer required
Parent is exiting
Many systems do not allow a child to continue if its parent terminates  cascading termination

29. 3.4 Interprocess Communication
Independent process cannot affect or be affected by the execution of another process
Cooperating process can affect or be affected by the execution of another process
Example: producer-customer problem
Environment for process cooperation
Information sharing
Computation speed-up
Modularity
Convenience
Two models of interprocess communication
Shared memory, message passing

30. Message Passing, Shared Memory

31. Producer-Consumer Problem
Common paradigm for cooperating processes
Producer process produces information that is consumed by a consumer process
Producer and customer must be synchronized, so the customer does not try to consume an item that has not been produced
Unbounded-buffer producer-consumer problem
Places no practical limit on the size of the buffer
Consumer may have to wait for new items; producer can always produce new items
Bounded-buffer producer-consumer problem
Assumes a fixed buffer size
Customer must wait if the buffer is empty; producer must wait if the buffer is full

32. Shared-Memory Solution to the Bounded Buffer Problem
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
Shared variables In
Out

33. Shared-Memory Solution to the Bounded Buffer Problem
(Only Use BUFFER_SIZE-1 Elements)
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
Shared variables In
Out
item nextProduced;
while (1) {
while (((in + 1) % BUFFER_SIZE) == out)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE; }
item nextConsumed;
while (1) {
while (in == out)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE; }
 Animation

34. 3.4 Interprocess Communication (IPC)
Message passing enables processes to communicate and to synchronize their actions
Processes communicate with each other without resorting to shared variables
IPC facility provides at least two operations
send(message) – message size fixed or variable
receive(message)
P and Q wishing to communicate need to
Establish a communication link between them
Exchange messages via send/receive

35. 3.4 Interprocess Communication
Implementation of communication link
Physical (e.g., shared memory, hardware bus)
Logical (e.g., logical properties)
Implementation questions
How are links established?
Can a link be associated with more than two processes?
How many links can there be between every pair of communicating processes?
Link capacity?
Size of a message on a link is fixed or variable?
Unidirectional or bi-directional link?

36. 3.4 Interprocess Communication
Logical implementation of a link
Direct or indirect communication
Symmetric or asymmetric communication
Automatic or explicit buffering
Send by copy or send by reference
Fixed-sized or variable-sized messages

37. 3.4 Interprocess Communication: Direct Communication
Processes must name each other explicitly
send(P, message): send a message to process P
receive(Q, message): receive a message from Q
Properties of communication link
Links are established automatically
A link is associated with exactly one pair of communicating processes
Between each pair there exists exactly one link
The link may be unidirectional, but is usually bi-directional

38. Example: The Producer-Consumer Problem
producer process consumer process
While (TRUE) {
...
produce an item in nextp
send(consumer,nextp); }
While (TRUE) {
receive(producer,nextc);
...
consume the item in nextc }

39. 3.4 Interprocess Communication: Indirect Communication
Messages are sent to and received from mailboxes (ports)
Each mailbox has a unique id.
send(A, message): send a message to mailbox A
receive(A, message): receive a message from mailbox A
Properties of communication link
Link established only if processes share a common mailbox
A link may be associated with many processes
Each pair of processes may share several communication links
Link may be unidirectional or bi-directional

40. 3.4 Interprocess Communication: Indirect Communication (續)
Operations
Create a new mailbox
Send and receive messages through mailbox
Destroy a mailbox
Mailbox sharing
P1, P2, and P3 share mailbox A
P1, sends; P2 and P3 receive
Who gets the message?
Allow a link to be associated with at most two processes
At most one process at a time executes a receive operation
The system selects arbitrarily one receiver. Sender is notified who the receiver was

41. Indirect Communication: Who Owns the Mailbox?
Owned by a process
Distinguish between the owner and the user
Owner: receive messages
User: send messages
Owned by OS
OS provides a mechanism allowing a process to
Create a new mailbox
Send and receive messages through the mailbox
Destroy a mailbox
Garbage collection for deleted mailboxes

42. 3.4 Interprocess Communication: Synchronization
Message passing may be either blocking or non-blocking
Blocking is considered synchronous
Non-blocking is considered asynchronous
send and receive primitives may be either blocking or non-blocking
Blocking send
Sending process blocks until message is received
Nonblocking send
Blocking receive
Receiver blocks until message is available
Nonblocking receive
Receiver retrieves either a valid message or a null

43. 3.4 Interprocess Communication: Buffering
A link has some capacity determining the number of messages that can reside (be queued) in it temporarily
Implementation
Zero capacity (queue length = 0)
The sender must wait until the recipient receives the message
This synchronization is called a rendezvous
Bounded capacity (queue length = n)
Wait when the queue is full
Unbounded capacity
Sender is never delayed

44. 3.5 Interprocess Communication: Mach Example
§3.5自行研讀; 不列入考試範圍
3.5 Interprocess Communication: Mach Example
Mach (Message-based OS)
Developed at Carnegie Mellon University
Provide multiple threads of control
Most communication is carried out by messages
Messages are sent to and received from mailboxes, called ports in Mach
Even system calls are made by messages
When each task is created, a Kernel mailbox and a Notify mailbox are also created
The former is used by the kernel to communicate with the task
Kernel sends notification of event occurrences to the Notify port

45. 3.5 Interprocess Communication: Mach Example
Only three system calls are needed for message transfer
Msg_send
Msg_receive
Msg_rpc (send a message and waits for exactly one return message from the receiver)
The port_allocate system call creates a new mailbox and allocates space for its queue of messages

46. 3.5 Interprocess Communication: Mach Example
send and receive operations are quite flexible
If the mailbox is not full, the message is copied and the sending thread continues
Otherwise, the sending thread has four options:
Wait indefinitely until there is room in the mailbox
Wait at most n milliseconds
Do not wait at all, but return immediately
Temporarily cache a message (OS keeps only one such message)

47. 3.6 Communication in Client-Server Systems: Socket
A socket is defined as an endpoint for communication (IP address concatenated with a port #)
Socket :1625 refers to port 1625 on host
Communication consists between a pair of sockets

48. Consider this “Date” server:
Sockets in Java
3 types of sockets
Connection-oriented (TCP)
Connectionless (UDP)
MulticastSocket class– data can be sent to multiple recipients
Consider this “Date” server:

49. 3.6 Communication in Client-Server Systems: Remote Procedure Call (RPC)
Remote procedure call abstracts procedure calls between processes on networked systems
Stub (存根、票根): client-side proxy for the actual procedure on the server
Client-side stub locates the server and marshals (安排整齊、列隊) the parameters
Parameter marshalling packages the parameters into a form which may be transmitted over a network
Server-side stub receives this message, unpacks the marshaled parameters, and performs the procedure on the server

50. 3.6 Communication in Client-Server Systems: Remote Procedure Call (RPC)

51. 3.6 Communication in Client-Server Systems: Execution of Remote Procedure Call (RPC)

52. 3.6 Communication in Client-Server Systems: Ordinary Pipes
Ordinary pipes allow communication in standard producer-consumer style
Producer writes to one end (the write-end of the pipe)
Consumer reads from the other end (the read-end of the pipe)
Ordinary pipes are therefore unidirectional
Require parent-child relationship between communicating processes
Windows calls these anonymous pipes
See Unix and Windows code samples in textbook

53. 3.6 Communication in Client-Server Systems: Named Pipes
Named pipes are more powerful than ordinary pipes
Communication is bidirectional
No parent-child relationship is necessary between the communicating processes
Several processes can use the named pipe for communication
Provided on both UNIX and Windows systems