Computer Operating System - Chapter 3: Processes

Nội dung text: Computer Operating System - Chapter 3: Processes

1. Chapter 3: Processes ■ Process Concept ■ Process Scheduling ■ Operations on Processes ■ Inter-Process Communication (IPC) ■ IPC in Shared-Memory Systems ■ IPC in Message-Passing Systems ■ Examples of IPC Systems ■ Communication in Client-Server Systems Operating System Concepts 2 Silberschatz, Galvin and Gagne ©2018
2. Process Concept ■ An operating system executes a variety of programs that run as processes ■ Process – a program in execution; process execution must progress in sequential fashion ■ Multiple parts ● The program code, also called text section ● Current activity including program counter, and processor registers ● Stack containing temporary data 4 Function parameters, return addresses, local variables ● Data section containing global variables ● Heap containing memory dynamically allocated during run time Operating System Concepts 4 Silberschatz, Galvin and Gagne ©2018
3. Process in Memory (memory limits of a process) #size Operating System Concepts 6 Silberschatz, Galvin and Gagne ©2018
4. 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 Operating System Concepts 8 Silberschatz, Galvin and Gagne ©2018
5. Process Control Block (PCB) ■ Process Control Block (PCB) – Information associated with each process, also called Task Control Block (TCB), includes: ● Process state – running, waiting, etc. ● Process number – identity of the process ● Program counter – location of instruction to next execute ● CPU registers – contents of all process-centric registers ● CPU scheduling info – priorities, scheduling queue pointers ● Memory-management information – memory allocated to the process ● Accounting information – CPU used, clock time elapsed since start, time limits ● I/O status information – I/O devices allocated to process, list of open files Operating System Concepts 10 Silberschatz, Galvin and Gagne ©2018
6. Process Representation in Linux ■ Represented by the C structure task_struct pid t_pid; /* process identifier */ long state; /* state of the process */ unsigned int time_slice /* 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 */ Operating System Concepts 12 Silberschatz, Galvin and Gagne ©2018
7. Ready and Wait Queues Operating System Concepts 14 Silberschatz, Galvin and Gagne ©2018
8. CPU Switch from Process to Process ■ A context switch occurs when the CPU switches from one process to another. Operating System Concepts 16 Silberschatz, Galvin and Gagne ©2018
9. Multitasking in Mobile Systems ■ Some mobile systems (e.g., early version of iOS) allow only one process to run, others suspended ■ Due to screen real estate, user interface limits iOS provides for a ● Single foreground process – controlled via user interface ● Multiple background processes – in memory, running, but not on the display, and with limits ● Limits include single, short task, receiving notification of events, specific long-running tasks like audio playback ■ Android runs foreground and background, with fewer limits ● Background process uses a service to perform tasks ● Service can keep running even if background process is suspended ● Service has no user interface, small memory use Operating System Concepts 18 Silberschatz, Galvin and Gagne ©2018
10. Process Creation ■ Parent process create children processes, which, in turn create other processes, forming a tree of processes ■ Process identified and managed via a Process Identifier (pid) ■ Resource sharing options ● Parent and children share all resources ● Children share subset of parent’s resources ● Parent and child share no resources Operating System Concepts 20 Silberschatz, Galvin and Gagne ©2018
11. A Tree of Processes in Linux #pstree Operating System Concepts 22 Silberschatz, Galvin and Gagne ©2018
12. C Program Forking A Separate Process Operating System Concepts 24 Silberschatz, Galvin and Gagne ©2018
13. Process Termination ■ Process executes last statement and then asks the operating system to delete it using the exit() system call. ● Returns status data from child to parent (via wait()) ● Process’resources are deallocated by operating system ■ Parent may terminate the execution of children processes using the abort() system call. Some reasons for doing so: ● Child has exceeded allocated resources ● Task assigned to child is no longer required ● The parent is exiting and the operating systems does not allow a child to continue if its parent terminates Operating System Concepts 26 Silberschatz, Galvin and Gagne ©2018
14. Importance Hierarchy of Android Process ■ Mobile operating systems often have to terminate processes to reclaim system resources such as memory. From most to least important: ▲ Foreground process ▲ Visible process ▲ Service process ▲ Background process ▲ Empty process ■ Android will begin terminating processes that are least important. Operating System Concepts 28 Silberschatz, Galvin and Gagne ©2018
15. Inter-Process Communication (IPC) ■ Processes within a system may be independent or cooperating ● Independent process does not share data with any other processes executing in the system ● Cooperating process can affect or be affected by other processes, including sharing data ■ Reasons for cooperating processes: ● Information sharing ● Computation speed-up ● Modularity ● Convenience ■ Cooperating processes need Inter-Process communication (IPC) Operating System Concepts 30 Silberschatz, Galvin and Gagne ©2018
16. Inter-Process Communication – Shared Memory ■ An area of memory shared among the processes that wish to communicate ■ The communication is under the control of the users processes, not the operating system. ■ Major issues is to provide mechanism that will allow the user processes to synchronize their actions when they access shared memory. (Synchronization is discussed in great details in Chapters 6 & 7) Operating System Concepts 32 Silberschatz, Galvin and Gagne ©2018
17. 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 Operating System Concepts 34 Silberschatz, Galvin and Gagne ©2018
18. Consumer Process – Shared Memory item next_consumed; while (true) { while (in == out) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; /* consume the item in next consumed */ } Operating System Concepts 36 Silberschatz, Galvin and Gagne ©2018
19. Message Passing (Cont.) ■ If processes P and Q wish to communicate, they need to: ● Establish a communication link between them ● Exchange messages via send/receive ■ Implementation issues: ● 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? ● What is the capacity of a link? ● Is the size of a message that the link can accommodate fixed or variable? ● Is a link unidirectional or bi-directional? Operating System Concepts 38 Silberschatz, Galvin and Gagne ©2018
20. 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 ■ 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 Operating System Concepts 40 Silberschatz, Galvin and Gagne ©2018
21. Indirect Communication (Cont.) ■ Operations ● create a new mailbox (or port) ● 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 Operating System Concepts 42 Silberschatz, Galvin and Gagne ©2018
22. Message Passing – Synchronization ■ Message passing may be either blocking or non-blocking ■ Blocking is considered synchronous ● Blocking send – the sender is blocked until the message is received ● Blocking receive – the receiver is blocked until a message is available ■ Non-blocking is considered asynchronous ● Non-blocking send – the sender sends the message and continue ● Non-blocking receive – the receiver receives: 4 A valid message, or Null message ■ Different combinations possible ● If both send and receive are blocking, we have a rendezvous Operating System Concepts 44 Silberschatz, Galvin and Gagne ©2018
23. Consumer – Message Passing message next_consumed; while (true) { receive(next_consumed) /* consume the item in next_consumed */ } Operating System Concepts 46 Silberschatz, Galvin and Gagne ©2018
24. Examples of IPC Systems - POSIX ■ POSIX Shared Memory ● Process first creates shared memory segment shm_fd = shm_open(name, O CREAT | O RDWR, 0666); ● Also used to open an existing segment ● Set the size of the object ftruncate(shm_fd, 4096); ● Use mmap() to memory-map a file pointer to the shared memory object ● Reading and writing to shared memory is done by using the pointer returned by mmap(). Operating System Concepts 48 Silberschatz, Galvin and Gagne ©2018
25. Examples of IPC Systems - Mach ■ Mach communication is message based ● Even system calls are messages ● Each task gets two ports at creation – Task Self port and Notify port ● Messages are sent and received using the mach_msg() function ● Ports needed for communication, created via mach_port_allocate() ● Send and receive are flexible, for example four options if mailbox full: 4 Wait indefinitely 4 Wait at most n milliseconds 4 Return immediately 4 Temporarily cache a message Operating System Concepts 50 Silberschatz, Galvin and Gagne ©2018
26. Mach Message Passing - Client Operating System Concepts 52 Silberschatz, Galvin and Gagne ©2018
27. Examples of IPC Systems – Windows ■ Message-passing centric via advanced Local Procedure Call (LPC) facility ● Only works between processes on the same system ● Uses ports (like mailboxes) to establish and maintain communication channels ● Communication works as follows: 4 The client opens a handle to the subsystem’s connection port object 4 The client sends a connection request 4 The server creates two private communication ports and returns the handle to one of them to the client 4 The client and server use the corresponding port handle to send messages or callbacks and to listen for replies Operating System Concepts 54 Silberschatz, Galvin and Gagne ©2018
28. Pipes ■ Acts as a conduit allowing two processes to communicate ■ Issues: ● Is communication unidirectional or bidirectional? ● In the case of two-way communication, is it half or full-duplex? ● Must there exist a relationship (e.g., parent-child) between the communicating processes? ● Can the pipes be used over a network? ■ Ordinary pipes – cannot be accessed from outside the process that created it. Typically, a parent process creates a pipe and uses it to communicate with a child process that it created. ■ Named pipes – can be accessed without a parent-child relationship. Operating System Concepts 56 Silberschatz, Galvin and Gagne ©2018
29. 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 Operating System Concepts 58 Silberschatz, Galvin and Gagne ©2018
30. Socket Communication Operating System Concepts 60 Silberschatz, Galvin and Gagne ©2018
31. Sockets in Java – Client ■ The equivalent “Date” client Operating System Concepts 62 Silberschatz, Galvin and Gagne ©2018
32. Remote Procedure Calls (Cont.) ■ Data representation handled via External Data Representation (XDR) format to account for different architectures ● E.g., Big-endian (Motorola) and little-endian (Intel x86) ■ Remote communication has more failure scenarios than local ● Messages can be delivered exactly once rather than at most once ■ OS typically provides a rendezvous (or matchmaker) service to connect client and server Operating System Concepts 64 Silberschatz, Galvin and Gagne ©2018
33. Summary ■ A process is a program in execution, and the status of the current activity of a process is represented by the program counter, as well as other registers. ■ The layout of a process in memory is represented by four different sections: (1) text, (2) data, (3) heap, and (4) stack. ■ As a process executes, it changes state. There are four general states of a process: (1) ready, (2) running, (3) waiting, and (4) terminated. ■ A process control block (PCB) is the kernel data structure that represents a process in an operating system. ■ The role of the process scheduler is to select an available process to run on a CPU. Operating System Concepts 66 Silberschatz, Galvin and Gagne ©2018
34. Summary (Cont.) ■ A pipe provides a conduit for two processes to communicate. There are two forms of pipes, ordinary and named. Ordinary pipes are designed for communication between processes that have a parent- child relationship. Named pipes are more general and allow several processes to communicate. ■ UNIX systems provide ordinary pipes through the pipe() system call. Ordinary pipes have a read end and a write end. A parent process can, for example, send data to the pipe using its write end, and the child process can read it from its read end. Named pipes in UNIX are termed FIFOs. Operating System Concepts 68 Silberschatz, Galvin and Gagne ©2018
35. End of Chapter 3 Operating System Concepts Silberschatz, Galvin and Gagne ©2018