Lecture 4: Processes
Total Page：16
File Type：pdf, Size：1020Kb
Lecture 4: Processes Fall 2018 Jason Tang Slides based upon Operating System Concept slides, http://codex.cs.yale.edu/avi/os-book/OS9/slide-dir/index.html Copyright Silberschatz, Galvin, and Gagne, 2013 "1 Topics • Process Concept! • Process Lifecycle! • Scheduling! • Process Creation and Termination "2 Process Concept • An OS executes processes (programs in execution)! • Text section: executable code! • Program counter and processor registers: current state of CPU! • Stack: function parameters, return addresses, local variables! • Heap: dynamically allocated variables! • Data section: global variables "3 Process Concept • Program is passive, stored as an executable file on disk, while a process is active! • Program becomes a process when executable file loaded into memory! • Execution of program begins with a double-click, tap an app, etc.! • Single program can cause several processes! • Such as by multiple users executing the same program "4 Process Memory Layout For most operating systems and CPUs, stack grows downwards (towards address 0). "5 Process Lifecycle • A process transitions through several states during its lifetime! • New: process is being created, memory allocated and initialized! • Running: process is using the CPU to execute instructions! • Waiting: OS has suspended process because it is waiting for I/O, timer, or some other event to occur! • Ready: process has all necessary resources, but something else is occupying CPU currently! • Terminated: process has finished execution; OS is cleaning it up "6 Process Lifecycle "7 Process Control Block • OS represents each process within a Process Control Block (PCB) (also known as a task)! • Process state! • Unique process identifier! • Program counter! • Scheduling information - task priority! • Memory management - memory allocated to process "8 Process Control Block • Accounting information - CPU time spent, time elapsed! • I/O status - list of open files, network connections! • Security information - owner of process! • CPU registers - copy of registers when process is suspended "9 CPU Switch from Process to Process "10 Threads • A process with multiple program counters, one per thread! • Threads may be simultaneously executing on multiprocessor system! • PCB contains separate sections for each thread "11 Processes in Linux • Represented by C structure task_struct struct task_struct { … /* -1 unrunnable, 0 runnable, >0 stopped: */ volatile long state; /* * This begins the randomizable portion of task_struct. Only * scheduling-critical items should be added above here. */ randomized_struct_fields_start void *stack; atomic_t usage; /* Per task flags (PF_*), defined further below: */ unsigned int flags; unsigned int ptrace; … /* Filesystem information: */ struct fs_struct *fs; /* Open file information: */ struct files_struct *files; … } From include/linux/sched.h "12 Process Scheduling • While one process is waiting, OS runs another process! • Process scheduler: mechanism for how OS chooses which ready process to run next! • Scheduling queue: queues of processes, categorized by process state! • Job queue: set of all processes in system! • Ready queue: processes waiting to execute! • Device queue: processes waiting for I/O to finish "13 Process Scheduling • Queueing diagram represents queues, resources, flows "14 Schedulers • Short-term scheduler (or CPU scheduler) - selects which ready process to execute next! • Invoked frequently (every few milliseconds / microseconds)! • Invoked after handling an interrupt or a system call! • Long-term scheduler (or job scheduler) - selects which processes to bring into ready queue, used for batch processing! • Invoked infrequently (every few seconds or even minutes)! • Not present in all operating systems "15 Schedulers • Medium-term scheduler - moves suspended processes from main memory to secondary storage (swap out), or vice versa (swap in)! • Sometimes combined with long-term scheduler "16 Choosing Scheduling Algorithms • Generally, processes are of one type or another:! • I/O-bound - spends majority of time waiting for I/O or user interaction; many short CPU bursts, followed by long waiting times! • CPU-bound - spends majority of time performing calculations; few but long CPU bursts! • Schedulers must balance time spent running CPU-bound processes with interactiveness expected by I/O-bound processes "17 Context Switch • Context switch: when CPU switches to another process, it saves state of original process (registers, program counter) to main memory, and then loads from memory the new process’s state (registers, program counters)! • Context of process represented by its PCB! • During a context switch, system is not doing any useful work! • Time to make context switch based upon hardware; some architectures faster than others! • More complex OSes have more complex context switches! • Larger context switch means slower computer response time "18 Process Creation • Parent process creates child processes, which create grandchild processes, forming a process tree! • Each process has a unique process identifier (PID)! • Resource sharing options:! • Parent and children share all resources, or children share subset, or children share no resources! • Execution options:! • Parent and children execute concurrently, or parent waits for children to terminate "19 Example Linux Process Tree $ pstree -h -p -G systemd(1)!"!ModemManager(344)!"!{ModemManager}(373) # $!{ModemManager}(377) %!NetworkManager(340)!"!dhclient(12487) # %!{NetworkManager}(413) # $!{NetworkManager}(416) … %!systemd(483)!"!(sd-pam)(484) # %!at-spi-bus-laun(733)!"!dbus-daemon(738) # # %!{at-spi-bus-laun}(734) # # %!{at-spi-bus-laun}(735) # # $!{at-spi-bus-laun}(736) … # %!gnome-shell-cal(813)!"!{gnome-shell-cal}(814) # # %!{gnome-shell-cal}(816) # # %!{gnome-shell-cal}(827) # # %!{gnome-shell-cal}(828) # # $!{gnome-shell-cal}(1036) # %!gnome-terminal-(1277)!"!bash(1299)!!!pstree(28960) "20 Unix Process Creation • Typical pattern is fork() and then exec()! • fork - OS creates child process, that is duplicate of parent’s PCB! • Child PCB gains its own PID, and starts running at the parent’s PC! • execute - OS then replaces the memory space (text and data sections) with new program "21 Example Fork/Exec Pattern (Unix) #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main(void) { pid_t pid = fork(); if (pid < 0) { // error occurred fprintf(stderr, "fork failed\n"); exit(EXIT_FAILURE); } else if (pid == 0) { // child process execlp("/bin/ls", "ls", NULL); fprintf(stderr, "exec failed\n"); exit(EXIT_FAILURE); } // parent process waitpid(pid, NULL, 0); printf("Child process done\n"); exit(EXIT_SUCCESS); } "22 Process Termination • Process ends when it executes last statement, it prematurely quits (such as exit() function), or some other process forcibly terminates it (such as by sending it a kill() signal)! • OS stores return status data from child, so that parent can retrieve it later (via wait() or equivalent)! • OS releases the rest of process’s resources! • Closes files, deallocates memory, other cleanup activities! • In Linux, this process becomes a zombie until parent reaps the return value "23 Process Termination • For some OSes, if a parent process terminates, the OS will automatically terminate its child processes (and recursively grandchildren, etc.)! • For other OSes, a parent can terminate without causing this cascading termination! • If a parent terminates without reaping its children, those child process become orphans! • In Linux, the init process (typically PID 1) becomes the orphans’ new parent "24.