Process

• the program code (also called text section)
• stack containing temporary data
  • E.g., function parameters, return addresses, local variables
• data section containing global variables and static variables
• heap containing memory dynamically allocated during run time
• program counter, processor registers (include all current )

overhead

• the system does no useful work while switching

dependent on the complexity of OS

• The more complex the OS and the PCB， the longer time the context switch

dependent on hardware support

• some hardware provides multiple sets of registers per CPU multiple contexts loaded at once, (no need to switch context when load another process to run)

• Some operating systems do not allow child to exist if its parent has terminated.
• When parent is terminated, all children, grandchildren, etc. are terminated.
• The termination is initiated by the operating system.

A zombie process is living corpse, half alive and half dead
terminated, but still consumes system resources
- still has an entry in the process table
- where the entry is still needed to allow the parent process to read its child's exit status.
- once the exit status is read by parent via the wait system call, the zombie's entry is removed from the process table ("reaped“).

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
int main(){
	pid_t pid = fork(); 
	if (pid == 0) { /* Child */
		printf("Running Child, PID = %d\n", getpid());	
		exit(0); 
	} 	
	else {	
		printf("Terminating Parent, PID = %d\n", getpid());
		while (1) ; /* Infinite loop */
	} 
     return 0;
}

子程序结束却并未通过wait()回收

Performed by parent on terminated child
Parent is given exit status information (by OS)
Kernel discards process

If any parent terminates without reaping a child, then child will be reaped by init or system process
So, only explicitly reaping is needed when parent is a long- running processes. e.g., shells and servers

An orphan process is child process that is still running but parent process has finished or terminated.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> 
#include <sys/types.h> 
int main(){
	pid_t pid = fork(); 
	if (pid == 0) { /* Child */
		printf("Running Child, PID = %d\n", getpid());
		while (1) ; /* Infinite loop */
	} else {	
		printf("Terminating Parent, PID = %d\n", getpid());
		exit(0); 
	} 
	return 0; 
}

父进程结束了却没有回收子进程

• Independent process cannot affect or be affected by another process
• Cooperating process can affect or be affected by other processes, because they share data

1. Information sharing
2. Computation speed-up
3. Modularity
4. Convenience

1. Added complexity
2. Deadlocks (死锁) possible
3. Starvation (饥饿) possible

• Shared memory //user processes control
• Message passing //kernel control
• Pipe Communication
  

Endpoint for communication 通讯的终结点
A number included at start of message packet to differentiate network services on a host

A data structure inside the kernel that represents the local end of a network connection
IP and Port

1. The client-side stub (server proxy)
   • Locates the server
   • Marshals the parameters
   • Sends parameters to server-side stub in a network message
2. The server-side stub (client proxy)
   • Receives this message
   • Unpacks the marshaled parameter
   • Performs the procedure call on the server, marshals the result of the call
   • Sends it back to the client-side stub in another message
3. The client-side stub
   • Receives this second message
   • Unpacks the marshaled result
   • Gives it back to the client that did the RPC

• Manages the network connection between client and server
• Extra code on the client side and server side
• Typically, a separate stub exists for each separate remote procedure
• On Windows, stub code compile from specification written in Microsoft Interface Definition Language (MIDL)

Use External Data Representation (XDR) format to account for different CPU architectures
Data Representation can be different in different CPU
-

• On the client side, parameter marshaling involves converting the machine-dependent data into XDR before they are sent to server.
• On the server side, the XDR data are un-marshaled and converted to the machine-dependent representation for the server.