Operating Systems CMPSC 473

1. Operating SystemsCMPSC 473 Processes August 31, 2010 - Lecture 3 Instructor: Bhuvan Urgaonkar

2. Teaching Assistant Name : Ohyoung Jang Office Hour : 2:30pm ~ 4:30pm, Mon Wed Location : 338E IST E-mail : oyj5007@cse.psu.edu 2/22

3. Contents Sample Program Compiling in Unix How to use gdb Makefile 3/22

4. Sample Program << main.c >> #include <stdio.h> #include <string.h> void print_hello(char* name); int compute_intsum(int); int main(int argc, char** argv) { int sum; int n = 100; char* name1 = "Ohyoung"; char* name2 = "Another long name"; sum = compute_intsum(100); printf("sum from 1 to %d is %d\n", n, sum); print_hello(name1); strcpy(name1, name2); print_hello(name1); return 0; } << src1.c >> #include <stdio.h> void print_hello(char* name) { printf("Hello %s.\n", name); } int compute_intsum(int n) { int i; int sum = 0; for (i = 1; i <= n; i++) { sum += i; } return sum; } 4/22

5. Contents Sample Program Compiling in Unix How to use gdb Makefile 5/22

6. Compiling in Unix man(1) gcc • Use gcc for c, or g++ for c++ to compile, link and generate executable • “-c” option for compile • If omitted, gcc/g++ links object files and make executable file • “-g” option for insert debug infos • To use gdb, this option is required. 6/22

7. Compiling in Unix • Use gcc for c, or g++ for c++ • Options • “-Ox” option for optimization level • 0 : no-optimization (required for gdb) • 1-5 : optimization level. Higher number -> more opt • “-I” for set include directories • “-L” for setting library directories • “-o” for setting output file • Infile • src or object files 7/22

8. Compiling in Unix Compile main.c with debug info with no-optimization output file is main.o Make executable with main.o and src1.o • Example • Compile source files • Link all object files to make an executable 8/22

9. Compiling in Unix • Easier example • Compile and Link in a command 9/22

10. Contents Sample Program Compiling in Unix How to use gdb Makefile 10/22

11. How to use gdb Program is terminated due to a trap Just type “gdb <executable>” • You may face error before you use gdb • You may expect “Another long name” instead of segmantatino fault 11/22

12. How to use gdb gdb console Output of the program Program terminated. But process infos remains. Then type “bt” or “backtrace” 12/22

13. How to use gdb Call stackwith frame number Print variableError. Current frame is 0 Change from to 1 Print variable The bug is found 13/22

14. How to use gdb • Another GDB commands • help [command] • b(reak) : set breakpoint • b <filename>:<lineno> [condition] • b <function_name> [condition] • Ex) b src1.c:15 if i == 10 • Ex) b compute_intsum • info b(reak) : list breakpoints • delete <breakpoint n> 14/22

15. How to use gdb • Another GDB commands • r(un) [argument] • Start program • s(tep) • Step program until it reaches a different src line • n(ext) • Like “step” command, as long as subroutine calls do not happen • c(ontinue) • Continue program until breakpoints or signals 15/22

16. 16/22

17. Contents Sample Program Compiling in Unix How to use gdb Makefile 17/22

18. Makefile The “make” utility automatically determines which pieces of a large program need to be recompiled, and issues commands to recompile them.[1] To use “make” utility, we need “Makefile” file. Makefile is consisted of variables and rules 18/22

19. Makefile << Makefile >> CC = gcc CFLAGS = -O0 -g OBJS = main.o \ src1.o TARGET=test build: $(OBJS) gcc -o $(TARGET) $(OBJS) rebuild: clean build clean: rm -rf $(OBJS) rm -rf $(TARGET) Variables Rules • Usage • To build • $make [build] • To clean • $make clean • To rebuild • $make rebuild 19/22

20. Makefile Define Rules <target name>:<prerequisite rules> \t<command1> \t<command2> .. Define Rules <target name>:<prerequisite rules> \t<command1> \t<command2> .. << Makefile >> CC = gcc CFLAGS = -O0 -g OBJS = main.o \ src1.o TARGET=test build: $(OBJS) gcc -o $(TARGET) $(OBJS) rebuild: clean build clean: rm -rf $(OBJS) rm -rf $(TARGET) Predefined Rules %.o : %.c $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ Automatic Variables %< : The name of the first prerequisite %@ : The name of the target 20/22

21. Makefile 21/22

22. Reference [1]http://www.gnu.org/software/make/manual/make.html 22/22

23. Last class • Interrupts, traps, signals • Introduction to processes • Address space • Process life-cycle

24. Tutorial on gdb

25. Project 1

26. Process Control Block (PCB) Process state • Process state • Process id (PID) • Program counter • CPU registers • CPU scheduling information • Memory-management information • Accounting information • I/O status information today Process id Program counter CPU registers Memory limits later List of open files . . .

27. CPU switch among processes

28. Enumerating # Possible CPU Multiplexing Between Processes • Consider two processes P1 and P2 • P1: n instructions • P2: m instructions • No jump instrictions => No loops • How many unique executions are possible?

29. Data structs associated with PCBs • Queue of ready (runnable) processes • Scheduler picks from these • Queues of waiting (blocked) processes • Sepearate queues for difference devices • Sometimes PCB of exited process kept in memory • Pop quiz: Why? • All PCBs in a part of RAM reserved by the kernel for itself and inaccessible to processes • This part of RAM initialized during boot-up

30. Data Structure #1: PCB Main Memory (RAM) Process id OS • Can PCBs be swapped out? • Depends on the OS design .. so sometimes YES Program Counter Other registers Process state Processes Ptr to linked list …

31. Running Ready Lock Waiting Disk

32. Timer interrupt Running Ready Lock Waiting Disk

33. Running Ready Lock Waiting Disk

34. I/O call Running Ready Lock Waiting Disk

35. Lets pick the second process in the ready queue Running OS (scheduler) Ready Lock Waiting Disk

36. Modern Kernels are Re-entrant Process 1 Process 1 Process 2 • Note: Not showing scheduler invocations • A re-entrant kernel is able to suspend the current running process even if it is in the Kernel Mode • Several processes may be in Kernel Mode at the same time • Usually one or more “kernel mode stacks” used when in kernel mode • Kept in kernel’s address space USER MODE KERNEL MODE One KCP Excp Intr Intr Kernel control paths Time Intr

37. Re-entrant Kernels Process 1 Process 1 Process 2 • Note: Not showing scheduler invocations • Why re-entrancy? • Improves throughput of devices controllers that raise interrupts • Allows priorities among interrupts USER MODE KERNEL MODE One KCP Excp Intr Intr Kernel control paths Time Intr

38. Relationships among processes • Several relatives of P recorded in its PCB • real_parent • Process that called fork to create P • Or init (process 1) • parent • Usually real_parent • Kernel signals this parent process when child exits • Or process that issues ptrace () to monitor P • Pop quiz: If you run a background process and exit the shell, who is the parent of the process? • children • siblings • Why maintain these?

39. Creating Processes • fork () • Take 1: Used in older kernels • Create a copy of the entire address space of the parent • Create a new PCB for the new process • Update parent, children, sibling pointers • Place the new process in the ready queue • S . L . O . W .

40. RAM Id=2001 Id=2000 State=ready 1. PCB with new id created State=ready OS PCB of parent PCB of child 2. Memory allocated for child Initialized by copying over from the parent Process calls fork 3. If parent had called wait, it is moved to a waiting queue 4. If child had called exec, its memory overwritten with new code & data Processes Parent’s memory Child’s memory 5. Child added to ready queue, all set to go now!

41. Creating Processes • fork () • Problems with Take 1 • Child rarely needs to read/modify ALL the resources inherited from the parent • Often, it immediately issues an execve() rendering all the effort that went into copying the address space useless!

42. Creating Processes: COW • fork () • What modern kernels do to avoid this waste of precious CPU time • Use Copy-On-Write • Basic idea: Postpone work till the last minute • Sounds familiar? Think assignments, quizzes, …

43. Process Switch • Suspend the current process and resume a previously suspended process • Also called context switch or task switch

44. A1 A2 Process Switch Involuntary/Voluntary Process 1 Process 0 Context_switch() { } B1 B2 B3 B4

45. Process Switch • What does the kernel need to save when suspending a process? • Hint: The entire address space is already saved (either in memory or on swap space). What else would the process need when it has to be resumed? • CPU registers • This is called the hardware context of the process • Execution context, PC, pointers to elements within address space, page table, etc.

46. Context_switch() { push R0, R1, … // save regs on its stack PCB[curr].SP = SP // save stack pointer PCB[curr].PT = PT // save ptr(s) to address space next = schedule() // find next process to run PT = PCB[next].PT SP = PCB[next].SP pop Rn, … R0 return // NOTE: Ctrl returns to another process }

47. Overheads of Process Switch • Direct • The time spent switching context • Indirect • Cache pollution • TLB flush