Categories of Processes Process program in execution Independent

Categories of Processes Process: program in execution • Independent process do not affect others • Cooperating process affect each other – Share memory and/or resources. – Overlap I/O and processing – Communicate via message passing. • I/O-bound – Short CPU bursts between I/O • CPU-bound process – Long CPU bursts, little I/O Note: The term, job, normally refers to a batch system process

A Process in Memory

Process States • As a process executes, it changes state – – – new: The process is being created running: Instructions are being executed waiting: The process is waiting for some event to occur ready: The process is waiting to be assigned to a process terminated: The process has finished execution

What makes up a process? • Process Control Block – – – Process Id Process State Scheduling Information Child and Parent data Per Thread • Program Counter • CPU Registers • Stack – – Allocated resources (file list) Accounting information I/O or wait status information Memory-management data • Program Instructions (text area) • Program Data and Heap Process States

Processing Management Involves migrating processes between queues Doubly Linked Lists Goal: Mix of I/O bound (filling I/O queues) and CPU bound (filling ready queue) • • Job queue – All system processes Ready queue – All processes in memory and ready execute Device queues – All processes waiting for an I/O request completes Process migrate between the various queues depending on their state

Process Schedulers • Long-term (What multiprogramming degree? ) – Slow; runs infrequently in the background, when processes terminate • Medium-term (Which to swap? ) – Efficient; runs roughly every second, when a process needs memory • Short-Term (which to dispatch next? ) – Must be fast; runs often (i. e. every 100 ms), after every interrupt

Context Switches Taking control from one process and giving it to another • Save the old process state and load the saved new process state • Context-switch time – pure overhead, no useful work done – Cost dependent on hardware support • Time slicing gives CPU cycles in a round -robin manner

Process Creation • Parent spawn children, children spawn others • Resource sharing options – Parent and children share all resources – Children share some parent resources – No sharing • Execution options – Parent and children execute concurrently – Parent waits until children terminate • Address space options – Child is a duplicate of the parent – Child space has a program loaded into it

A Solaris process spawning tree Root of all user processes File management Support Remote Telnet/FTP Memory management X Windows

POSIX Example fork: Child is a clone of the parent exec: replace memory with new program

Win 32 Example

Java Example Runs separate process, which could be a separate JVM Get Process System. out. println output Note A JVM is a separate application, supporting multiple threads Only one process resides within a single JVM

Process Termination • Process tells OS that is done (exit(0) or System. exit(0)) – Resources are de-allocated – Status value (usually an integer) is returned • Parent may terminate child processes (abort()) – Child has exceeded allocated resources – Child is no longer needed – Some operating system perform cascading termination, (automatic child process termination if a parent terminates) • Parent may wait for child to terminate (wait()) – The child's pid is returned, facilitating process management – Solaris: if a parent terminates, init becomes the parent

Cooperating Processes Definition: Processes that affect each other's state • Reasons – – Share Data Speedup: Breaking a task into pieces and execute in parallel Increase modularity of a complex application Enhance user convenience: Pipeline a series of algorithmic steps • Modes of Communication – Shared Memory: • System call maps shared memory into logical space of each process • Mutual exclusion techniques required • Faster; Processes directly access shared memory without OS help – Message Passing: • Easier to program: No critical sections or locking mechanisms needed • Slower: System calls required for send/receive operations

Inter-process Communication Message Passing Shared Memory

Producer-Consumer Problem Example: Cooperating processes • unbounded-buffer: No practical buffer size limit • bounded-buffer: A limited fixed-sized buffer Note: Java can share memory between threads, but not among separate JVM processes

Shared-Memory Solution public interface Buffer { public abstract void produce(Object item); public abstract Object consume(); } public class Bounded. Buffer implements Buffer { private int count, in, out; private Object[] buffer; public Bounded. Buffer(int size) { count = in = out = 0; buffer = new Object(size); } public void produce(Object item) { while (count == buffer. length) ; buffer[in] = item; in = (in + 1)%buffer. length; count++; } public Object consume() { while (count == 0) ; Object item = buffer[out]; out = (out + 1)%buffer. length; count--; return item; } }

Message Passing • Message system – processes send and receive to communicate – send(P, message) // Send to process P – receive(Q, message) // Receive from process Q • To communicate, P and Q must: – establish a communication link between them – exchange messages via send/receive • Communication link can be: – physical (e. g. , shared memory, hardware bus) – logical (e. g. , logical properties)

Implementation Questions • • • How to establish links? Network, memory, hardware, etc. ? Number of processes sharing a link? Number of links per process? Capacity? 0 -length (no buffering), bounded queue length, unbounded? Variable or fixed sized messages? Unidirectional or bi-directional? Synchronous/asynchronous? Blocking/non-blocking send/receive Symmetry/Asymmetry? Sender and receivers name each other or not? Direct/indirect communication? By hard-coded pid, or mailbox/port? Copy message data or remap memory? Communication standard? Protocol? Persistent or transient? Messges lost after owner terminates?

Direct Communication • Processes name each other explicitly: – send (P, message) – send to process P – receive(Q, message) – receive from process Q • Properties of communication link – – Links are established automatically A link connects exactly one pair processes Between each pair there exists exactly one link Links are usually bi-directional

Indirect Communication • Messages sent/received using ports (mailboxes or ports) – A mailbox has a unique id; processes communicate using the id – Mailboxes may or may not persist when a processer terminates – Mailboxes can be owned by a process or by the OS. • Properties of communication links – – Processes share common mailbox links A link may be associated with many processes Processes may share many communication links Link may be unidirectional or bi-directional • Operations or OS system calls – – – create or destroy mailboxes send and receive messages through mailbox Delegate send and receive privileges send(A, message) – send a message to mailbox A receive(A, message) – receive a message from mailbox A

Indirect Communication Issue • Mailbox sharing – P 1, P 2, and P 3 share mailbox A – P 1, sends; P 2 and P 3 receive – Who gets the message? • Possible Solutions – Links shared by at most two processes – Only one process can receive messages – Arbitrarily select the receiver and notify sender

Synchronization • Blocking: Synchronous – Blocking send: The sender block until the message is received – Blocking receive: The receiver block until a message is available • Non-blocking: Asynchronous – Non-blocking send has the sender send the message and continue – Non-blocking receive has the receiver receive a valid message or null

Buffering • Buffering: The link queues messages • Queue length 1. Zero capacity – queue length = 0 Sender waits for receiver (rendezvous) 2. Bounded capacity – queue length=n Sender must wait if the link is full 3. Unbounded capacity – infinite length Sender never waits

Message Passing Solution public class Unbounded { private Vector queue; public Unbounded() { queue = new Vector(); } public void send(Object item) { queue. add. Element(item); } public Object receive() { if (queue. size() == 0) return null; else return queue. remove. Element. At(0); } } // Producer while(true) { send(new Date()); } // Consumer while(true) { Date msg = (Date)receive(); if (msg != null) System. out. println(msg); }

Message Passing in Windows XP Server establishes a port When client wants to communicate, a handle is sent to server and client Shared memory if >256 bytes Small messages copied, larger messages use memory mapping

Socket Communication Definition: A socket is an endpoint for communication • • Concatenation of IP address and port (ex: 161. 25. 19. 8: 1625) Local host for loopback: 127. 0. 0. 1 Socket port numbers below 1024 are considered well-known Socket class for Connection-oriented (TCP) sockets, Datagram. Socket class or Multicast. Socket class for connectionless (UDP) sockets, Note: Communication occurs between a pair of sockets

Java Socket Server 1. 2. 3. 4. 5. 6. Establish a listening port number Accept a client connection Get the connection's output stream Write the data Close the connection Continue listening for requests

Java Socket Client 1. 2. 3. 4. Establish a connection to the server Get the connection's output stream Read the data Close the connection

Remote Procedure Calls (RPC) • Remote procedure call (RPC) abstracts procedure calls between processes on networked systems • Higher level abstraction on top of socket communication • The data is very structured (function/method calling data) • Implementation – Client Side (issues an RPC call as if it were local) 1. 2. 3. 4. Calls a stub (a proxy for the server side procedure) The stub marshalls the parameters for communication The message is sent to the server The stub receives the result and returns to the caller – Server-side (listens on a designated RPC port) 1. 2. A stub receives request, un-marshalls data and calls procedure The returned data is sent back to a waiting client

RPC Considerations • Reliability: What happens when the server fails? Possible solution: provide redundant servers • Multiple calls: Retries trigger duplicate processing. Solution: Time stamp messages/process duplicate requests "at most once" • Port binding: Solution: Use fixed port numbers or provide a rendezview operation to establish port connections • Data representation – Big endian (most significant byte first) versus little endian (least significant byte first) – Size and format of various data types – Serializing memory addresses – Solution: Machine independent external data representation (XDR) • Disadvantage: Overhead compared to local procedure calls. • Advantage: Flexibility and single-point hosting of data

RPC Execution

Remote Method Invocation (RMI) • Remote Method Invocation: Java-based mechanism • Difference from RPC: Links to remote Objects, passing serialized (java. io. Serializable) objects as parameters

Marshalling Parameters

Server Side: Define Remote Objects • Declare an interface to: – Specify the signatures for the accessible methods – The interface extends java. rmi. Remote. Exception • Implement a program that listens for RMI requests – A main method creates an instance of the remote object and registers it with an appropriate name so it can listen for RMI requests through Java's socket scheme – The main class implements the RMI interface and extends java. rmi. server. Unicast. Remote. Object – A default constructor is necessary, throwing a Remote. Exception if a network failure occurs

// The RMI interface // The implementation RMI Server

RMI Client // The same interface as on the server Client RMI Call 1. Lookup and connect to the host 2. Call the method as if it were local

Implementation Steps 1. Compile the source files 2. Generate the stub (rmi compiler) a. Before Java 1. 5, rmic Remote. Date. Impl b. After Java 1. 5, this is done automatically 3. Start the RMI registry in the background a. Unix: rmiregistry & b. Windows: start rmiregistry 4. Connects server RMI objects to registry: java Remote. Date. Impl 5. Reference remote objects from client: java RMIClient Advantages compared to Socket Programming 1. RMI is a high level implementation; the registry abstracts socket management 2. Clients do not have to package the data and deal with data representation issues

Threads (Linux: tasks) A path of execution through a process

Motivation for Threads • Responsiveness: An application continues executing when a blocking call occurs • Resource Sharing: All threads can share an application's resources • Economy: Creating new heavyweight processes is expensive time wise and consumes extra memory • Parallel Processing: Threads can simultaneously execute on different cores Note: Internal kernel threads concurrently perform OS functions. Servers use threads to efficiently handle client requests

User and Kernel Threads • User threads - Thread management done by user-level threads library without OS support. Less system calls – more efficient • Kernel threads – Thread management directly supported by the kernel. More OS overhead • Tradeoffs: Kernel thread handling incurs more overhead. User threads stops the application on every blocking call. • Most modern operating systems support kernel threads (Windows, Solaris, Linux, UNIX, Mac OS).

Many-to-One Model Thread managed by a run time library (more efficient) • A blocking call will suspend the application • All threads run on a single core • Examples: Green threads (on a virtual machine) and GNU portable threads (OS is not aware of the threads)

One to One Thread management is done in the kernel • Disadvantages – Increased overhead – Upper limit on the total number of threads • Advantage: Maximum concurrency; blocking OS calls don't suspend applications • Examples: Windows XP, Linux, Solaris

Many-to-Many Thread management shared by kernel and user level libraries • Kernel thread pool assigned to an application and managed by a thread library • Advantages – Eliminates user thread number limit – Applications don't suspend on blocking OS calls – Increased thread efficiency while maintaining concurrency • Disadvantage: Up calls from the kernel to the thread library • Example: Windows XP Thread Fiber library Two level threads: A many-to-many model. The kernel maps threads onto processors, and the run-time thread library maps user threads onto kernel threads

Many-to-many Thread Scheduling Issue: How many kernel threads? • Too many means extra OS overhead • Too few means processes block 1. The kernel assigns a group of kernel threads to a process 2. Up-calls: kernel -> thread library a. If the process is about to block b. If a blocked kernel thread becomes ready c. Thread allocations to be released (freed) Note: A Kernel process sitting between user and kernel threads assist with thread management. These are often called light weight processes (LWP)

Threading Issues • Does spawning a new process spawn all threads or only the one that is executing? Example: fork() duplicates all threads, exec() replaces the process with a single thread • How do we cancel a thread? What if it is working with system resources? Approaches: asynchronous or Synchronous cancellation • How do we minimize overhead of continually creating threads? Answer: Thread pools • How do threads communicate? Linux: Signals to notify a thread of an event, Windows: Asynchronous procedure calls that function like callbacks. • How do we create data that is local to a specific thread? Answer: Thread specific data • How are threads scheduled for execution? One possibility: Light weight processes

Pthreads Example (Sum numbers) void main ( int argc , char argv[] ) { thread_t[] handles; int t, threads=strtoi(argv[1], NULL, 10); pthread_mutex_t mtx = pthread_mutex_init(&mtx, NULL); handles = malloc(threads*sizeof(pthread_t )); for (t=0; t<threads; t++) pthread_create(&handles[t], NULL, add. Them, (void*)&t); for ( t= 0 ; t < threads; t ++) pthread_join(handles[t], NULL); printf ( "Total = %dn", sum); free(handles) ; pthread_mutex_destroy(&mtx); } void* add. Them( void *rank ) { int my. Rank = (int) (*rank) ; double my. Sum = 0; int i, my. N = 10000/threads; int first = my. N*my. Rank; int last = first+my. N; f o r (i=first; i<last ; i++) { my. Sum += i; } pthread_mutex_lock(&mtx) sum += my. Sum; pthread_mutex_unlock(&mtx); }

open. MP Example (Sum numbers) int main ( int argc , char argv[] ) { double sum = 0. 0 , int threads = strtoi(argv[1], NULL, 10); #pragma omp parallel num_threads(threads) reduction(+: sum) f o r (i=0; i<last ; i++) { sum+= i; } printf ( "Total = %dn", sum); } Note: open. MP is a popular industry-wide thread standard

Java Threads • Java threads are managed by the JVM and generally utilize an OS provided thread-based library • Java threads may be created by: – Implementing the Runnable interface – Extending the Thread class • Java threads start by calling the start method – Allocate memory for the thread – Call the start method • Java threads terminate when they leave the run method

Java Thread States • The is. Alive() method returns true if a thread is not dead. • Note: The get. State() method returns values of DONE, PENDING, STARTED

Java Threads (Sum numbers) public class Driver extends Thread { private static double sum = 0. 0; private int upper; public Driver(int upper) { this. upper = upper; this. start(); } public static void main(String[] args) { Driver thread = new Driver(Integer. parse. Int(args[0])); thread. join(); System. out. println("Total = " + sum); } public void run() { sum = 0; for (int i=0; i<upper; i++) sum += i; } }

Java Producer/Consumer class Producer implements Runnable { private Vector<Date> mbox; public Producer(Vector<Date> mbox) { this. mbox = mbox; } public void run() { while(true) { Thread. current. Thread. sleep((int)Math. random(100)); mbox. add(new Date()); } } } class Consumer implements Runnable { private Vector<Date> mbox; public Consumer(Channel mbox) { this. mbox = mbox; } public void run() { while(true) { Thread. current. Thread. sleep((int)Math. random(100)); if ((!mbox. is. Empty()) System. out. println((Date)mbox. remove(0)); } } public class Factory { public Factory() { Vector<Date> mail. Box = new Vector<Date>(); new Producer(mail. Box). start(); new Consumer(mail. Box). start(); } public static void main(String[] args) { Factory server = new Factory(); } }

Java Thread Cancellation Example: Kill the loading of a Web page in a browser • Asynchronous: immediately cancel the thread. Can lead to problems if the thread has partially completed a critical function and thread owned resources may not be reclaimed (Java: stop()) • Deferred: A thread periodically checks for termination at cancellation points. The thread then cancels itself. Spawn the thread and then interrupt it Thread thread = new My. Thread(). start(); { … } thread. interrupt(); Periodically check if interrupted in the thread's run method Thread. current. Thread. is. Interrupted() // preserve interrupted signal Thread. current. Thread. interrupted() // reset interrupt signal

Example Thread thread = new Thread(new Interruptible. Thread()); thread. start; . . . thread. interrupt(); class Interruptible. Thread implements Runnable { /** This thread runs till interrupted */ public void run() { while(true) { / ** do processing till reach a cancellable point */ if (Thread. current. Thread(). is. Interrupted()) { System. out. println("I'm interrupted!"); return;

Signal Handling Example: Illegal memory access • UNIX systems use signals to notify a process that a an event has occurred • Signal handler methods process signals 1. Signal generated by particular event 2. It is delivered to a process 3. It is handled • Options: – – Deliver the signal to the thread waiting for the signal (synchronous) Deliver the signal to every thread in the process (ctrl-C) Deliver the signal to selected threads in the process Assign a specific thread to receive all signals • User processes can override the kernel default handler

Thread Pools A group of threads created in advance that await work to do • Advantages – Eliminates overhead thread creation and destruction overhead – Applications can control the size of the pool – Avoid creating an unlimited number of threads which can tax system resources • Java Options – Single thread executor - pool of size 1. Executors. new. Single. Thread. Executor() – Fixed thread executor - pool of fixed size. Executors. new. Fixed. Thread. Pool(int n. Threads) – Cached thread pool - pool of unbounded size Executors. new. Cached. Thread. Pool() Note: Dynamic thread pools adjust the number of threads based on system load

Thread Pool Example Import java. util. concurrent public class Some. Thread implements Runnable { public void run() { System. out. println(new Date()); } } public class Pool { public static void main(String[] args) { int tasks=Integer. parse. Int(args[0]. trim()); Executor. Service pool = Executors. new. Cached. Thread. Pool(); for (int i=0; i<num. Tasks; i++) pool. execute(new Some. Thread()); pool. shutdown(); }

Thread Specific Data Each thread can have its own local data • Motivation: Useful to avoid critical sections in thread pools • Java scoping facilities – Normal scoping: variables belong to instantiated objects – Static scoping: variables belong to the class – Thread. Local: content of these objects belong to particular threads using get and set methods. They are usually declared to be static class Service { // Thread local objects associate contents with thread instances private static Thread. Local error. Code = new Thread. Local(); public static void transaction() { try { // some operation } catch (Exception e) { error. Code. set(e); } } public static Object get. Error. Code() { return error. Code. get(); } }