Lecture 3: Processes. CMPUT 379, Section A1, Winter 2014 January 13, 15 and 17

Transcription

1 Lecture 3: Processes CMPUT 379, Section A1, Winter 2014 January 13, 15 and 17

2 Objectives Understand the notion of a process : a program in execution which forms the basis of all computation Understand key features of running processes, including state, creation, termination and scheduling Understand some basic concepts in Inter Process Communication (IPC) 2

3 What is a process? A process is a program in execution, with components the program to be executed the data on which to execute the program the required resources (e.g. memory and files) status of execution (e.g. waiting, running, terminated) process!= program e.g. program tar can be executed by two different people - same program (shared code) as part of different processes 3

4 Programming: uni- versus multi- Uniprogramming systems allow execution of only one process at a time (e.g. early personal computers) Multiprogramming systems allow concurrent execution of many processes (e.g. current PCs) multiprogramming!= multiprocessing In a multiprogramming system, CPU switches between processes, running each for tens or hundreds of milliseconds. In reality, the CPU is running only one process at a time, though many seem to run concurrently 4

5 Execution model Execution Model: runnable software on the computer (including components of the OS itself) is organized into a number of (sequential) processes each process is viewed as a block of code with a pointer showing the next instruction to be executed The OS deals with concurrency (i.e. allowing several processes to share one CPU) by ensuring each process gets a chance to run fair scheduling the processes do not modify each other s state protection 5

6 Process States: a process is an entity A process is a living entity in stages of life: New a process being created but not yet included in the pool of executable processes (resource acquisition). Ready prepared to execute when given the opportunity. Active/Running currently being executed by the CPU. Waiting/ Blocked cannot execute until some event occurs. Stopped is a special case of blocked where the process is suspended by the operator or the user. Exiting a process that is about to be removed from the pool of executable processes (resource release). 6

7 Processes moving between states 7

8 Video Break, as brought to you by one of your amazing classmates 8

9 Process scheduling Objective of multiprogramming is to have some user process running at all times; OS keeps CPU busy with productive work by dynamically selecting (scheduling) the next user process to become active. The (re)-scheduling is performed by a module called the dispatcher, which usually only executes the following primitive pseudo-code: loop forever { run the process for a while. stop process and save its state. load state of another process. } 9

10 Process queues The processes that need to be scheduled are maintained in queues Job queue set of all processes in the system Ready queue set of all processes residing in main memory and waiting to execute Device queues set of processes waiting for an I/O device Processes migrate among the various queues 10

11 Control of the CPU CPU can only do one thing at a time. While user process is running, dispatcher cannot run; OS could lose control How does the dispatcher regain control (of the CPU)? Trust process to wake up dispatcher when done (sleeping beauty approach) Provide a mechanism to wake up dispatcher (alarm clock) What are the problems with the sleeping beauty approach? 11

12 Context switch When an event occurs, OS saves the state/info of the active process & restores state of the interrupt service routine; this mechanism is called a context switch What must be saved? Everything the next process will damage, but the current process needs to be continued correctly, such as: program counter stored in register, indicates the address of to next instruction to be executed for the process general purpose registers since will almost definitely be overwritten file access pointers other processes could modify the same files 12

13 Maintaining process information with a Process Control Block (PCB) To manage and control processes, OS needs to maintain two types of info process state info: e.g. CPU registers - contents of all process-centric registers program counter - location of next instruction to execute process control info: e.g. scheduling priority resources held - e.g. list of open files memory allocated process state process number program counter registers memory limits list of open files 13

14 Context switch from process to process process P 0 operating system process P 1 interrupt or system call executing save state into PCB 0 idle reload state from PCB 1 idle interrupt or system call executing save state into PCB 1 reload state from PCB 0 idle executing 14

15 What happens as processes are moving between states? 15

16 Research question: fast context switching Context switching is pure overhead, so want to reduce wasted computation Avoid saving anything unnecessary, e.g. reduce number of registers to save by performing context switches at points in the program where only a small subset of the registers are live Hardware-based solutions 16

17 PCB representation and queues in Linux The PCB is represented by task_struct, which contains some variant of the following (depending on the Linux version). The processes are connected with a doubly-linked list, with a pointer to the current process. pid t_pid; /* process identifier */ long state; /* state of the process */ unsigned int time_slice /* scheduling information */ struct task_struct *parent; /* this process s parent */ struct list_head children; /* this process s children */ struct files_struct *files; /* list of open files */ struct mm_struct *mm; /* address space of this process */ 17

18 Linux Example: <linux/sched.h> Examine process struct: lines in sched.h Examine how change state of a process: line 220 in sched.h One way to get better at programming in c and learn some tricks is to examine good c code (i.e. Linux code), e.g. Why does the Linux code seem to always declare struct task_struct t instead of simplifying with typedef, i.e. using typedef struct task_struct { }; Task and declaring Task t? Why do the macros have a do { stuff } while(0)? 18