Chapter 3: Processes

1. Chapter 3: Processes

2. Chapter 3: Processes • Process Concept • Process Scheduling • Operations on Processes • Cooperating Processes • Interprocess Communication • Communication in Client-Server Systems

3. Process Concept • An operating system executes a variety of programs: • Batch system – jobs • Time-shared systems – user programs or tasks • Textbook uses the terms job and process almost interchangeably • Process – a program in execution • A process includes • Code (or text) • Data • Stack • Current values of the program counter and registers

4. Process Image in Memory (1/2)

5. Process Image in Memory (2/2) • Logical view of process image in memory 3.1.1 Fig 3.1

6. Process State • 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 processor • terminated: The process has finished execution

7. Diagram of Process State 3.1.2 Fig 3.2

8. Source program: /* test.c */ int main(int argc, char** argv) { printf(“Hello world\n"); exit(0); } Compile in Linux: gcc test.c –o test Run test: ./test A process test will be created, executed, and terminate. Process test runs through following states (in the best case): new ready running waiting (I/O due to call of printf) ready running terminated Process State -- Example

9. Process Control Block (PCB) PCB stores the information associated with each process • Process state • Program counter • CPU registers • CPU scheduling information • Memory-management information • Accounting information • I/O status information 3.1.3

10. Process Control Block (PCB) • One of the most important data structures in operating systems 3.1.3 Fig 3.3

11. CPU Switch from Process to Process Fig 3.4

12. Process Scheduling Queues • Job queue – set of all processes entering the system • Ready queue – set of all processes residing in main memory, ready and waiting to execute • Device queues – set of processes waiting for an I/O device • Queues can be implemented as lists of PCB’s • Processes change state  they migrate among the various queues 3.2.1

13. Ready Queue and Various I/O Device Queues 3.2.1 Fig 3.5

14. interrupt occurs Queueing Diagram 3.2.1 Fig 3.6

15. Schedulers (1/3) • Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue • UNIX and MS Windows have no long-term scheduler • Short-term scheduler (or CPU scheduler) – selects which process should be executed next and allocates CPU

16. memory memory Schedulers (2/3) • Addition of medium-term scheduling to regulate the degree of multiprogramming • The medium term scheduler swaps out/in processes between memory and disk to decrease/increase the number of processes in memory

17. Schedulers (3/3) • Short-term scheduler is invoked very frequently (milliseconds)  must be fast • Long-term scheduler is invoked very infrequently (seconds, minutes)  may be slow • The long-term scheduler controls the degree of multiprogramming • 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

18. Context Switch • Context switch: When CPU switches to another process, the system must save the data about the old process and load the previously saved data for the new process • Contextof a process is represented in the PCB • Context-switch time is the time needed by OS to do a context switch • Context-switch time is overhead; the system does no useful work while switching • Context-switch time is dependent on hardware support 3.2.3

19. Process Creation (1/3) • In Linux, Windows and many OSes, process can create new processes (children, child processes), which in turn create other processes, forming a tree of processes. • Resource (files,…) sharing possibilities, dependent on OS, • Parent and children share all resources • Children share subset of parent’s resources • Parent and child share no resources • Execution possibilities • Parent and children execute concurrently • The OS blocks the parent until the child finishes 3.3.1

20. Process Tree Linux/Unix root pagedaemon swapper init bash bash bash gcc ls mkdir grep

21. Process Creation (2/3) • In UNIX • New processes are not created from scratch (except for?) • fork system call creates new process • new process is identical to its parent process; only differences are their process id’s and the return value from the fork. • Why fork? exec system call used after a fork to replace the process’ memory space with a new program ( command interpreter)

22. Process Creation (3/3) 3.3.1 Fig 3.10

23. C Program Forking Separate Process int main() { pid_t pid; /* fork another process */ return_value = fork(); if (return_value < 0) { /* error occurred */ fprintf(stderr, "Fork Failed"); exit(-1); } else if (return_value == 0) { /* child process */ execlp("/bin/ls", "ls", NULL); } else { /* parent process */ /* parent will wait for the child to complete */ wait (NULL); printf ("Child Complete"); exit(0); } } 3.3.1 Fig 3.9

26. Process Termination • Process executes last statement and asks the operating system to delete it (exit) • Output data from child to parent (via wait) • Process’ resources are deallocated by operating system • Parent may terminate execution of children processes (abort) • Child has exceeded allocated resources • Task assigned to child is no longer required • If parent is exiting • Some operating system does not allow child to continue if its parent terminates • All children terminated – cascading termination 3.3.2

27. Cooperating Processes • 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 • Advantages of process cooperation • Information sharing • Computation speed-up • Modularity • Convenience

28. Producer-Consumer Problem • Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process • unbounded-buffer places no practical limit on the size of the buffer • bounded-buffer assumes that there is a fixed buffer size

29. Bounded-Buffer – Shared-Memory Solution • Shared data #define BUFFER_SIZE 10 typedef struct { . . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0; • Solution is correct, but can only use BUFFER_SIZE - 1 elements

30. Bounded-Buffer – Insert() Method while (true) { /* Produce an item */ while (((in = (in + 1) % BUFFER SIZE count) == out) ; /* do nothing -- no free buffers */ buffer[in] = item; in = (in + 1) % BUFFER SIZE; }

31. Bounded Buffer – Remove() Method while (true) { while (in == out) ; // do nothing -- nothing to consume // remove an item from the buffer item = buffer[out]; out = (out + 1) % BUFFER SIZE; return item; }

32. Interprocess Communication (IPC) • Two models for process communication: • Using shared memory • Message passing – processes communicate with each other without resorting to shared memory 3.4

33. Communications Models Message passing Using shared memory 3.4 Fig 3.12

34. Direct Communication • Processes must name each other explicitly: • send(P, message) – send a message to process P • receive(Q, message) – receive a message from process Q 3.4.2.1

35. Indirect Communication (1/3) • Messages are directed to / received from mailboxes (also referred to as ports) • Each mailbox has a unique id • Processes can communicate only if they share a mailbox

36. Indirect Communication (2/3) • Operations • create a new mailbox • send and receive messages through mailbox • destroy a mailbox • Primitives are defined as: send(A, message) – send a message to mailbox A receive(A, message) – receive a message from mailbox A

37. Indirect Communication (3/3) • Mailbox sharing • P1 , P2 , and P3 share mailbox A • P1 sends; P2and P3 receive • Who gets the message? • Solutions • Allow only one process at a time to execute a receive operation • Allow the system to select arbitrarily the receiver. Sender is notified who the receiver was. 3.4.2.1

38. Blocking/Nonblocking Send/Receive • Blocking • Blocking sendhas the sender block until the message is received • Blocking receivehas the receiver block until a message is available • Non-blocking • Non-blocking send has the sender send the message and continue • Non-blocking receive has the receiver receive a valid message or null 3.4.2.2

39. Message Queue Length • Queue of messages; implemented in one of three ways 1. Zero capacity – 0 messagesSender must wait for receiver (rendezvous) 2. Bounded capacity – finite length of n messagesSender must wait if link full 3. Unbounded capacity – infinite length Sender never waits 3.4.2.3

40. Example of shared memory for IPC • POSIX Shared Memory • Process first creates shared memory segment segment id = shmget(IPC PRIVATE, size, S IRUSR | S IWUSR); • Process wanting access to that shared memory must attach to it shared memory = (char *) shmat(id, NULL, 0); • Now the process could write to the shared memory sprintf(shared memory, "Writing to shared memory"); • When done a process can detach the shared memory from its address space shmdt(shared memory);

41. Client-Server Communication • Examples • A program running on a workstation is the client of a file server, and requests it to perform operations on files. • A program with a graphical user interface running on a workstation is the client of the X server running on that workstation. The X server draws things on the screen for it, and notifies it when input is events have occured in its window. • A web browser is a client of a web server, and asks it for certain web pages. • An ATM is a client of a bank’s central computer, and asks it for authorization and recording of a transaction. • Techniques • Sockets • Remote Procedure Calls • Remote Method Invocation (Java) 3.6

42. Sockets • A socket is defined as an endpoint for communication • socket number (address) consists of IP address and port • The socket 161.25.19.8:1625 refers to port 1625 on host 161.25.19.8 • Well-known ports used for standard services 3.6.1

43. Communication Using Socket Browser at 3.6.1 Fig 3.17

44. Communication Using Socket • Socket primitives

45. Server accept() socket() bind() listen() recv() send() close() communication socket() send() recv() close() connect() Client Set up a Connection between Client and Server • send(socket, buffer, buffer_length, flags) • recv(socket, buffer, buffer_length, flags)

46. Remote Procedure Calls (1/3) • Remote procedure call (RPC) extends procedure call to call a procedure residing on a remote machine – a remote procedure. • Client programis bound with a client stub – a small library procedure. Server programis bound with a server stub • The client-side stub locates the server and marshalls the parameters. • The server-side stub • receives this message, • unmarshalls, i.e. unpacks, the marshalled parameters, • and performs the procedure on the server. 3.6.2

47. RPC (2/3) Fig from Feitelson

48. RPC (3/3) • Calling remote procedure add(i, j) Server stub Client stub

49. Execution of RPC 3.6.2 Fig 3.20

50. Remote Method Invocation • Remote Method Invocation (RMI) is a technique similar to RPC, but implemented on JVM. • RMI allows a Java program on one machine to invoke a method on a remote object. 3.6.3 Fig 3.21