Outlook. Process Concept Process Scheduling Operations on Processes. IPC Examples

Transcription

1 Processes

2 Outlook Process Concept Process Scheduling Operations on Processes Interprocess Communication o IPC Examples 2

3 Process Concept

4 What is a Process? A process is a program in execution Process includes Text section: program code Current activity: program counter, processor registers Process stack: method parameters, return address, local variables Data section: global variables Heap: dynamically allocated memory 4

5 Process State Only one process can be running on any processor at any time instant Many processes may be ready and waiting Scheduler: selects an available process for CPU execution Dispatcher: switches process from ready to running 5

6 Process Control Block (PCB) A PCB represents a process PCB is a repository for any information that may vary from process to process Process state Program counter CPU registers CPU-scheduling information Memory-management information Accounting information I/O status information Process ID 6

7 Process Scheduling

8 Motivation A short recap multiprogramming objective: have one process running at all time to maximize CPU utilization Time sharing objective: frequently switch CPU among processes to allow user interaction Task of the process scheduler: select a process among the set of ready processes all other processes remain ready and wait to be selected next ideally CPU or CPUs remain occupied 8

9 Scheduling gqueues Job queue: all processes Ready queue: processes waiting for CPU Device queue: processes waiting for I/O device 9

10 Queueing Diagram Representations Remark: Queuing theory for analyzing system performance depending on queuing network, process traffic, service times, and scheduling strategies 10

11 Schedulers Scheduling: selection of processes waiting in a queue Scheduler classes Short-term scheduler: select from ready queue the process which gets the CPU next Medium-term scheduler: reintroduce swapped processes into memory (see next slide) Long-term scheduler (useful for batch systems): select processes from mass-storage storage device and load them into memory for execution Short-term scheduler must be fast! Executes at least every 100ms E.g. 10ms to decide the next process? Long-term scheduler need not be computational fast Long-term scheduler must result in a good mix of I/O-bound processes: time spent mainly with I/O (keep IO busy) CPU-bound processes: time spent mainly with computation (keep CPU busy) 11

12 Schedulers Long-term scheduler are thought for batch systems UNIX and Windows systems have only short term scheduler Each new process is put in memory for short-term term scheduling Long term scheduling by the user(s) Medium-term schedulers and swapping 12

13 Context Switch Overhead depends on Memory speed Number of registers Special instructions Typically less than 10ms Speedup: multiple sets of registers (e.g. UltraSPARC) PCB Process state Program counter CPU registers CPU-scheduling information Memory-management information Accounting information I/O status information Process ID 13

14 Operations on Processes

15 Process Creation Process tree Creating process: parent Created processes: children Process ID Example: Solaris- System Exercise: try to find out the process tree on a UNIX system using ps el 15

16 Process Creation Resources for a sub process Obtain resources directly from OS Restricted to resources of parent Advantage: prevents system overload by a process spawning many child processes Initialization data from the parent Example: file name of an image or already opened file and an output t device Two possibilities in terms of execution Parent continues to run concurrently Parent waits until some or all children have been terminated Two possibilities in terms of memory Child process is a duplicate of the parent process (example fork) Child is newly loaded program code (example Win32) 16

17 UNIX Example: fork, exec, wait int main() { pid _ t pid; /* fork another process */ pid = fork(); if (pid < 0) { /* error occurred */ fprintf(stderr, "Fork Failed"); exit(-1); } else if (pid == 0) { /* child process */ exec("/bin/ls", "ls", NULL); } else { /* parent process */ /* parent will wait for the child to complete */ wait(); printf ("Child Complete"); exit(0); } } 17

18 Previous Example under Win32 int main() { STARTUPINFO si; PROCESS_INFORMATION pi; // prepare si and pi first //... if(!createprocess(null, C:\\WINDOWS\system32\mspaint.exe,,... /* many more parameters here */, &si, &pi) { // error handling return -1; } // parent will wait for child to complete WaitForSingleObject(pi.hProcess, t( i INFINITE); printf( Child Complete ); CloseHandle(pi.hprocess); CloseHandle(pi.hThread); 18

19 Process Termination Process terminates itself: exit Process terminates another one: abort (or TerminateProcess() in Win32 API) Usually only possible for terminating child processes from a parent process (to prevent arbitrary process termination) All resources of the process are deallocated What happens with child processes? All children are terminated as well cascading termination Assign all children to the init process Waiting for process termination: wait returns the ID of the exiting child process 19

20 Interprocess Communication

21 Cooperating Processes Independent processes: cannot affect or is not affected by other processes Cooperating processes: can affect or is affected by other processes Reasons for process cooperation Information sharing among several users Computation speedup by breaking it into subtasks and running it on parallel hardware if available Modularity by dividing large task into subtasks Convenience for one user Cooperation requires IPC mechanism Two fundamental models; see next slide 21

22 Message Passing and Shared-Memory Model Message passing useful for exchanging smaller amount of data simpler to implement no conflicts need to be avoided Easier for inter computer process communication Shared memory is faster Systemcalls to setup But then only plain memory access 22

23 Message Passing: Direct and Indirect Communication Direct communication Explicitly name the sender and receiver Symmetry in addressing send(p, message) receive(q, message) Asymmetry in addressing send(p, message) receive(id, message) Indirect communication Messages are sent and received from ports send(a, message) receive(a, message) Port either owned by process or operating system Advantage of ports: can be passed to other process without affecting the senders 23

24 Synchronization Message passing may either be blocking or nonblocking (synchronous, asynchronous) Possible combinations Blocking send Nonblocking send Blocking receive Nonblocking receive Rendezvous: blocking send and receive 24

25 Buffering Messages exchanged reside in temporary queue Possible variants Zero capacity (no buffering) Automatic buffering Bounded capacity Unbounded capacity 25

26 IPC Examples

27 POSIX Shared Memory int size = 4096; /* allocate a shared memory segment */ int segment_id = shmget(ipc_private, size, S_IRUSR S_IWUSR); /* attach the shared memory segment */ char* shared_memory = (char*)shmat(segment_id, NULL, 0); /* use the shared memory */ sprintf(shared_memory, Hi there! ); printf( %s\n, shared_memory); /* detach the shared memory again */ shmdt(shared_memory); /* remove shared memory segment from operating system */ shmctl(segment_id, IPC_RMID, NULL); 27

28 Windows XP Local Procedure Call (LPC) > 28

29 Client-Server-Communication: Sockets A socket is defined as an end point for communication Identified d by IP address and port number The socket :1625 refers to port 1625 on host Communication consists between a pair of sockets 29

30 Example: Java Date Server Server: ServerSocket socket = new ServerSocket(6013); while(true) { Socket client = sock.accept(); PrintWriter out = new PrintWriter(client.getOutputStream()); out.println(new Date().toString()); client.close(); } Client: Socket socket = new Socket( , 6013); BufferedReader d in = new BufferedReader( d new InputStreamReader(socket.getInputStream())); while(string line = in.readline()!= null) { System.out.println(line); } is a loopback address, i.e. refers to this socket.close(); 30 machine

31 Remote Procedure Call (RPC) Allows a client to invoke a procedure on a remote host as it would invoke the procedure locally Stubs hide the communication details Implements the method signature Send message to the server Receives method return value Passes result to calling process Server implemented by stubs as well Listen for incoming method call Call the service implementation to get the return value Send return value to client host 31

32 Remote Procedure Call (RPC) Requirements for calling the right function RPC daemon listening on a port (remark: network address would not be sufficient) Function identifier Well structured data formats Communication details hidden in so called stubs on the client and server side parameter passing (mashalling) sending and receiving Architecture dependent data representation E.g. 32-Bit integers in big- and little-endian Example of a machine independent representation: external data representation ti (XDR) client marshalling involves converting machine dependent data in XDR server unmarshalling involves converting XDR to server machine dependent representation 32

33 Remote Procedure Call (RPC) RPC looks like calling a local function However, local function call can fail only under extreme conditions RPC involves a network and its possible errors Message loss or duplicates that means: RPC can fail or be duplicated RPC call semantics At most once: achieved by attaching to each message a time stamp Exactly once: achieved by time stamps and RPC acknowledgements Locate the right port on the server Hard coded (well known ports for specific RPC procedures) Dynamic binding using matchmaker daemon 33

34 Example of RPC with Dynamic Binding 34

35 Example of RPC with Dynamic Binding 35

36 Remote Method Invocation (RMI) Java concept which allows invoking a method on a remote object Remote means residing on different JVMs Possible to pass objects as parameters RMI makes remote access transparent by using the following concepts Stub: proxy for the remote object Parcel: method name and marshalled parameters sent to the remote object Skeleton: object receiving the parcel, invoking the right object method on the server, and returning the result RMI Parameter Passing Local objects are serialized (have to implement Serializable) ) Remote objects are passed by reference 36

37 RMI Communication Example 37

38 Example: RMI Java Date Server The RemoteDate interface: public interface RemoteDate extends Remote { public Date getdate() throws RemoteException; } The RemoteDate t implementation: ti public class RemoteDateImpl extends UnicastRemoteObject t t implements RemoteDate t { public RemoteDateImpl() throws RemoteException() {} public Date getdate() throws RemoteException { return new Date(); } } 38

39 Example: RMI Java Date Server Registering and getting the RMI service: Server: Naming.rebind( DateServer, new RemoteDateImpl()); Client: RemoteDate server = (RemoteDate)Naming.lookup( lookup( rmi:// / 0 1/ DateServer ); Running the programs: Compile source files: javac Generate Stub and skeleton (before Java 5): rmic 39

40 Summary and References

41 Summary Process is the abstraction to allow multiprogramming and time-sharing Important related concepts: process states, processcontrol block, dispatching, scheduling Processes in an operating system typically form a child parent relation tree Processes are normally independent from each other Process communication sometimes required Message passing Shared memory Both schemes are not mutually exclusive; sometimes useful to apply both Process communication i over machine boundaries Sockets: remote communication is visible RPC, RMI: try to hide (as far as possible) the fact that network is involved 41

42 References Silberschatz, Galvin, Gagne, Operating System Concepts, Seventh Edition, Wiley, 2005 Chapter 3 Processes 42