1. Chapter 3 – Processes (Pgs 101 – 141)

2. Processes  Pretty much identical to a “job”  A task that a computer is performing  Consists of: 1. Text Section – Program Code 2. Data Section – Heap, Stack, & Free Space 3. Current State – CPU Register Values  Program: Passive entity on disk  Process: Active entity in memory  Thread:A part of a process (Ch. 4)

3. Process Layout (x86) c.f., Text Fig 3.1

4. Process States  New: Being created  Running: Has a CPU, being executed  Suspended: Not running (covers both ready and waiting)  Ready: Could be running if assigned to a CPU  Waiting: Needs something (e.g., I/O, signal)  Terminated: Done

5. Fig. 3.2 Process State

6. Process Control Block (PCB)  O/S (Kernel) Data Structure for a process  State - ready, etc.  Registers – current values, includes PC  Scheduling Info – priority, queue address  Memory Info – pages tables, base address  Accounting Info – owner, parent, CPU use, pid  I/O Status Info – open files, devices assigned

7. The Unix ps command tami@cs:0~]ps -l F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 0 S 1021 17012 17011 0 80 0 - 9848 rt_sig pts/18 00:00:00 zsh 0 R 1021 17134 17012 0 80 0 - 1707 - pts/18 00:00:00 ps tami@cs:0~]  F = Flags, S = State, UID = User, PID = Process  PPID = Parent, C = CPU % use, PRI = Priority  NI = Nice, ADDR = Swap Addr, SZ = Num pages  WCHAN = Kernel function where sleeping  TTY = Controlling Terminal Device  TIME = CPU Time, CMD = File Name  Lots of other data is available using options!

8. Scheduling Queues  Happy little places for processes to wait (just like the lines at Starbucks)  Job Queue: All processes in the system  Ready Queue: All processes ready to run  Device Queue(s): Processes waiting for a particular device (each has own queue)  Often just a linked list of PCBs

9. Queueing Diagram (Fig 3.7)

10. Scheduler  O/S component that selects a process from a queue  Long term (job): select process to be loaded into memory (make ready)  Short term (cpu): select ready process to run  I/O: select process from the I/O queue for that device  Context Switch: Changing the executing process on a CPU; requires saving state of outgoing process, restoring state (if any) of incoming process

11. Process Mix  Computers work best when a variety of processes with different needs exist  CPU-bound process: most of its life is computations, very little I/O  I/O-bound process: most of its life is spent doing I/O, minimal computation  Long term scheduling works best if a mix of these is in memory

12. Medium Term Scheduler  Monitors memory and removes some processes which it writes to disk (“swap out”)  Later moves the process back to memory so it can be executed (“swap in”)  Will cover this more in Ch. 8  Used to free memory of a process that cannot execute (blocked because it needs resources).

13. Process Creation  All processes have a parent  Thus there is a process tree  Every process has a PID  Two step process in Unix 1. Create a new (duplicate) process : fork() 2. Overlay duplicate with new program: exec()

14. Fork() and Exec() (Fig 3.10) pid_t pid = fork(); // Duplicate myself if (pid < 0) error(); // No child, parent OK if (pid == 0) { // Child, don’t know own pid execlp(“/bin/ls”,”ls”,NULL); } else { // Parent w. opt. wait for child completion wait(NULL); printf(“Child complete.\n”); }

15. fork() : Making a COPY  The copy is identical. Has same code, same heap, same stack, same variables with same values  Only difference is that child has different PID and PPID

16. Forking  After fork(), either child or parent, or both, could be executing – no guarantees here!  wait() causes parent to wait for child to terminate  exec family of syscalls overlays child process  Additional coding must be performed to allow parent and child to communicate (IPC)

17. Termination  Processes terminate with the exit() syscall  GCC inserts it for you after the last executable instruction (or a jmp to it if many exit points)  Some O/S terminate all children of a terminating process, “cascading termination”  Parents can terminate their children  Arbitrary processes cannot terminate each other  O/S can terminate a process for a variety of reasons (e.g., security, on errors)  Exit value of a terminated process is stored for a while (e.g., until reboot or PID reused)

18. Summary (Unix)  New processes made by an existing process using FORK  New process is a copy of the old  Both parent and child are running after the FORK  New process must get new program and data using EXEC  Parent can WAIT for child or continue  Processes terminate using EXIT

19. Interprocess Communication  Efficiency: Save having 2 copies of something by letting it be shared  Performance: Sharing results of parallel computations  Co-ordination: Synchronising the transfer of results, access to resources etc.  Two primary reasons: 1. Coordination/Synchronisation 2. Data transfer

20. IPC Models (SGG) 1. Shared Memory – common memory location for both processes to read and write 2. Message Passing – kernel acts as a go- between to receive and send messages (shared memory is managed by the kernel instead)  But, really, its always just some kind of shared memory and there are more than two models

21. IPC Models  Shared memory  Message passing  Mailboxes & Ports  Remote Procedure Calls  Pipes  Interrupts (users to O/S)  Signals (limited information content)

22. Producer-Consumer Problem  Producer creates something  Consumer uses that product  Consumer must wait for it to be produced and fully put into memory  Producer must wait for consumer to create space where the product can be put if the space fills up  Requires careful communication and synchronisation

23. Shared Memory  O/S normally prevents one process from accessing the memory of another  Requires setup to be effective  Processes must somehow co-operate to share the memory effectively or else they can over-write each other’s data  Simultaneous writes cause a big mess!

24. Unix Shared Memory  A “key” is used to name the shared segment. Any process with the key can access it.  The segment is located using shmget()  The segment is attached using shmat()  Generally “fast” for doing communication  Uses standard Unix permission system  Highly useful techniques are possible  Read/Write coordination is needed

25. Message Passing  Uses the O/S to receive, buffer, and send a message  Uses the send() and receive() syscalls  What if a process tries to receive when nothing has been (or will be) sent?  Like shared memory, message passing requires careful coding and co-ordination by the two+ processes

26. Direct Communication  Uses process names (PIDs)  Requires knowing the PID of everyone we communicate with  If a process terminates, must find its PID and delete it  Main drawback is maintaining the list of active PIDs we communicate with  Send goes to only one process so multiple sends may be needed  Works great in many situations though

27. Indirect Communication  Uses mailboxes or ports  Mailbox is an O/S maintained location where a message can be dropped off or picked up  All mailboxes have a name  Multiple processes can read from the mailbox  Mailbox can be owned by O/S or a process  Still have the problem of communicating the mailbox name/location, but at least now the O/S knows this information as well

28. Synchronicity (Not the Police Album)  Message passing can be either: 1. Blocking / Synchronous 2. Non-Blocking / Asynchronous  Synchronous send() waits for receipt before returning  Synchronous receive() waits for the send to complete before returning  Asynchronous operations return even if no receipt occurs or if data is not available  When both are synchronous, we have a “rendezvous”

29. Buffering 1. Zero Capacity: There is no buffer and data is discarded if the communication is not synchronous 2. Bounded Capacity: The buffer is fixed size and sender blocks when the buffer fills 3. “Infinite” Capacity: O/S allocates more space to buffer as required

30. Remote Procedure Call (RPC)  A protocol designed so that a process on one machine can have computation performed by calling a procedure (function) that is executed by a different process on another machine  Issues with endianism, data encoding  Must define a common data representation  Issues with synchronisation of processes and returning of results

31. Sockets  Associated with Internet-based IPC  A socket is an IP address (a machine) and a specific port on that machine  We normally don’t see them because WWW services tend to have a default port, e.g., Port 80 for HTTP  Can use 127.0.0.1 (loopback) to test things, e.g., client and server on same machine http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers

32. Pipes  A connection (with buffer) for sending data  Data of any form can be sent  Best for one directional communication  Can be used two way if emptied between uses  Very common in Unix, considered as the most basic form of IPC  Named pipes (called FIFOs) are file system entities in Unix

33. To Do:  Complete this week’s lab  Finish reading Chapter 3 (pgs 101-141; this lecture) if you haven’t already