CIT 500: IT Fundamentals

1. CIT 500: IT Fundamentals Processes

2. Topics • Processors • Operation • Moore’s Law • Processes • Lifecycle • Virtual address space • Context switch • Managing processes • Scheduling

3. The Processor Aspects of performance • Clock speed (GHz.) • Instructions/clock cycle. • Number of cores. Architectures • IBM Power 5 • Sun UltraSPARC T2 • Intel Xeon, Itanium2 • AMD Opteron

4. Processor Operation • Fetch instruction from RAM. • Decode instruction. • Translate instruction to micro ops. • Determine what data is operated on. • Execute instruction.

5. Machine and assembly languages Machine language • Each CPU has its own. • Even different x86 CPUs have variants. • MMX, SSE, VME • cat /proc/cpuinfo Assembly language • Human representation • One-to-one correspondence of assembly codes to machine codes.

6. Inside the Itanium CPU

7. Moore’s Law

8. Limits of Moore’s Law More transistors ≠ greater speed • Adding more cores doesn’t make tasks faster if they cannot be split into multiple processes. Transistors can’t be smaller than atoms • Can add transistors by using bigger dies. • Can add transistors by going 3D. • Can improve speed without adding transistors.

9. What is a process? A process is a program in execution. Program code + dynamic execution context. Virtualization Processes provide virtual CPU + virtual memory.

10. What is in a process? A process consists of. Program code. Address space. Data. Resources: open files, signals. At least one thread of execution. Threads contain: Program counter. Stack. Register set.

11. Process Lifecycle

12. Process Address Space Process appears to have flat memory space. Discontinguous areas of physical memory mapped via page table to produce virtual memory. Virtual memory space 3GB virtual memory on 32-bit architectures. High 1GB reserved for mapping kernel memory.

13. 32-bit Process Address Space 0xBFFFFFFF stack ESP heap bss data text EIP 0x08000000

14. Translating Virtual to Physical Addrs

15. Virtual and Physical Addressing

16. Context Switch When does scheduler switch out process? Blocked on I/O. Time slice expires. How does it switch? Switch to new page table. Save hardware context to stack. Switch stack pointers. Load hardware context of next process from stack.

17. Context Switch Example

18. Where do processes come from? Kernel creates some processes. Kernel threads. init Processes create all other processes. Process copies itself with fork(). Original is parent, new process is child. Child can load its own program with exec().

19. Process Creation and Termination

20. fork() and exec() fork() system call creates a new process Initializes with copy of parent resources. Creates a new address space. Page table is copy-on-write pointer to parent. Places child process on ready queue. exec() system call replaces program with new one Loads program text from file. Replacing old program text. New program is executed in process.

21. Process Tree (Solaris)

22. Process Termination Voluntary exit() system call. Compiler automatically adds to binaries. Involuntary signal exception

23. Logging In login program • Checks password. • chdir to homedir. • chown terminal to user. • sets group IDs • initializes env variables • changes UID to user • execs login shell

24. Processes and the Shell Shells forks and execs each command. • Except for shell built-ins like cd. • Including each command in a pipeline. Shell waits for process to terminate. • Except if you end command line with &. • The jobs command will show processes started by the current shell.

25. Managing Processes: bg and fg Ctrl-z will suspend the current process. • Sends a SIGSTOP to the process. The bg command will background a process. • Still running, as if started with an & at end of line. • Use %NUM for job number arguments. • Use NUM for process ID arguments. The fg command will foreground a process. • Shell will wait for process to terminate. • Same arguments as bg.

26. Background Execution Techniques • Run the command with & at the end of line. • Remember output will still come to shell. • May want to redirect both STDOUT and STDERR. • Use ctrl-z to suspend current foreground job, then use bg to restart in background. • Remember output will still come to shell.

27. Subshells A separate instance of your command shell. Commands in parentheses execute in subshell. Execute commands in temp environment. (cd /; pwd; ls) Combine output of commands to pipeline. (cat smallFile; echo -e "\n\n-----\n\n"; cat mediumFile) | less Run multiple commands in background. (cp /boot/vm* kernel; bzip2 -9 kernel) &

28. The ps command ps – show current process a = list processes from all users, not just you x = list processes without a tty u = display user oriented format w = display wider format (for long command lines) > ps auxw|head USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.0 2620 1708 ? S Sep08 0:00 /sbin/init

29. The ps command Time (TIME) • CPU time used, not wall clock time. Resident Set Size (RSS) • Amount of physical memory currently used. Virtual Memory Size (VSZ) • Amount of virtual memory currently used. • Some of this memory is shared libraries, which • is space shared by multiple processes.

30. Shared Libraries Shared libraries contain commonly used code • Filesystem access • Data compression • Network access Two types of linking • Static: shared library incorporated in program code, programs works even if lib not installed. • Dynamic: shared library loaded at runtime, saves memory since only one copy loaded on system.

31. Shared Library Use > ldd /bin/cp linux-gate.so.1 => (0xbfffe000) libselinux.so.1 => /lib/libselinux.so.1 (0xb7f76000) libacl.so.1 => /lib/libacl.so.1 (0xb7f6f000) libc.so.6 => /lib/libc.so.6 (0xb7e35000) libdl.so.2 => /lib/libdl.so.2 (0xb7e31000) /lib/ld-linux.so.2 (0xb7f97000) libattr.so.1 => /lib/libattr.so.1 (0xb7e2d000)

32. Process Memory Use > cat /proc/1/maps 08048000-0805e000 r-xp 00000000 08:01 640163 /sbin/init 0805e000-0805f000 rw-p 00015000 08:01 640163 /sbin/init 0805f000-08168000 rw-p 0805f000 00:00 0 [heap] b7db8000-b7db9000 rw-p b7db8000 00:00 0 b7db9000-b7eec000 r-xp 00000000 08:01 658668 /lib/libc-2.7.so b7eec000-b7eed000 r--p 00133000 08:01 658668 /lib/libc-2.7.so b7eed000-b7eef000 rw-p 00134000 08:01 658668 /lib/libc-2.7.so b7eef000-b7ef2000 rw-p b7eef000 00:00 0 b7ef7000-b7ef9000 rw-p b7ef7000 00:00 0 b7ef9000-b7f13000 r-xp 00000000 08:01 658665 /lib/ld-2.7.so b7f13000-b7f15000 rw-p 00019000 08:01 658665 /lib/ld-2.7.so bfcfa000-bfd10000 rw-p bfcfa000 00:00 0 [stack] bfffe000-bffff000 r-xp bfffe000 00:00 0

33. Signals Software interrupts used for process communication. • SIGALRM: alarm() timer has gone off. • SIGHUP: sends signal to re-read config file. • SIGINT: interrupt signal generated by Ctrl-c. • SIGSEGV: segmentation violation sent by kernel when process accesses invalid address. • SIGSTOP: suspends process (ctrl-z) until SIGCONT. • SIGKILL, SIGTERM: terminates a process. Process can either • Ignore the signal: SIGKILL/STOP cannot be ignored. • Catch the signal: Create a signal handler function and register it with the kernel to be called on signal.

34. Sending signals with kill kill [-l] [-signal] PID … Sends specified signal to specified PIDs. Send SIGTERM if no signal specified. Signals can only be sent to your processes. [-l] List available signals instead of sending.

35. Scheduler Scheduler Part of operating system. Selects a process to run and allocates CPU to it. Provides semblence of multitasking on single CPU. Scheduler is invoked when: Process blocks on an I/O operation. A hardware interrupt occurs. Process time slice expires.

36. Types of Processes CPU Bound Spend most time on computations. Example: computer algebra systems. I/O Bound Spend most time on I/O. Example: word processor. Mixed Alternate CPU and I/O activity. Example: web browser.

37. Alternating CPU and I/O Bursts

38. Scheduling Policy Scheduler executes policy, determining 1. When threads can execute. 2. How long threads can execute. 3. Where threads can execute.

39. Scheduling Policy Goals Efficiency • Maximize amount of work accomplished. Interactivity • Respond as quickly as possible to user. Fairness • Don’t allow any process to starve.

40. Which goal is most important? Depends on the target audience: Desktop: interactivity But kernel shouldn’t spend all time context switch. Server: efficiency But should offer interactivity in order to serve multiple users.

41. Static and Dynamic Priorities Initial priority value called the nice value. Set via the nice or renicecommand. Static priority is nice value + 120. Ranges from 100 (highest) to 139 (lowest). Scheduling based on dynamic priority. Bonuses and penalties according to interactivity.

42. Time Slices Time slice duration critical to performance. Too short: high overhead from context switches. Too long: loss of apparent multitasking. Time slices are 100ms on average. Interactive processes and time slices Interactive processes have high priority. Pre-empt CPU bound tasks on kbd/ptr interrupts. Long time slices cause slow start of new tasks.

43. Scheduler Interrupts • Scheduler interrupt • Invoked every 1-10ms (depends on cfg) by timer interrupt. • Decrements task’s time slice. • If a higher priority task exists, • Higher priority task is given CPU. • Current task remains in TASK_RUNNING state. • If time slice expired, • Process moved to expired priority array.

44. Changing nice values nice –n val command • Start command and add n to nice value. • Nice ranges from -20 (highest pri) to 19 (lowest.) • Only root can use negative values. renice pri –p PID • Change nice value for specified process. • Can only do for your own processes. • Can only reduce the priority of your processes, i.e. • can only use positive values unless you are root.

45. References • Daniel P. Bovet and Marco Cesati, Understanding the Linux Kernel, 3rd edition, O’Reilly, 2005. • Avi Silberchatz et. al., Operating System Concepts, 7th edition, 2004. • W. Richard Stevens and Stephen Rago, Advanced Programming in the UNIX Environment, 2nd edition, 2005. • Nicholas Wells, The Complete Guide to Linux System Administration, Thomson Course Technology, 2005.