CS370 Operating Systems Midterm Review

Transcription

1 CS370 Operating Systems Midterm Review Yashwant K Malaiya Fall 2015 Slides based on Text by Silberschatz, Galvin, Gagne 1 1

2 What is an Operating System? An OS is a program that acts an intermediary between the user of a computer and computer hardware. Major cost of general purpose computing is software. OS simplifies and manages the complexity of running application programs efficiently. OS Views Resource allocator to allocate resources (software and hardware) of the computer system and manage them efficiently. Control program Controls execution of user programs and operation of I/O devices. Kernel The program that executes forever (everything else is an application with respect to the kernel). 2 2

3 A View of Operating System Services 3 3

4 Computer System Structures Computer System Operation I/O Structure: polling, interrupts, DMA Storage Structure Storage Hierarchy System Calls and System Programs Command Interpreter Some common commands: ps, fg, bg, kill etc. 4 4

5 Operating System Services Services that provide user-interfaces to OS Program execution - load program into memory and run it I/O Operations - since users cannot execute I/O operations directly File System Manipulation - read, write, create, delete files Communications - interprocess and intersystem Error Detection - in hardware, I/O devices, user programs Services for providing efficient system operation Resource Allocation - for simultaneously executing jobs Accounting - for account billing and usage statistics Protection - ensure access to system resources is controlled 5 5

6 Process Management Process - fundamental concept in OS Process is a program in execution. Process needs resources - CPU time, memory, files/data and I/O devices. OS is responsible for the following process management activities. Process creation and deletion Process suspension and resumption Process synchronization and interprocess communication Process interactions - deadlock detection, avoidance and correction 6 6

7 Process Concept An operating system executes a variety of programs batch systems - jobs time-shared systems - user programs or tasks job and program used interchangeably Process - a program in execution process execution proceeds in a sequential fashion A process contains program counter, stack and data section Process States e.g. new, running, ready, waiting, terminated. 7 7

8 Process Control Block Contains information associated with each process Process State - e.g. new, ready, running etc. Program Counter - address of next instruction to be executed CPU registers - general purpose registers, stack pointer etc. CPU scheduling information - process priority, pointer Memory Management information - base/limit information Accounting information - time limits, process number I/O Status information - list of I/O devices allocated 8 8

9 CPU Switch From Process to Process C structure task_struct 9 9

10 Process Creation Processes are created and deleted dynamically Process which creates another process is called a parent process; the created process is called a child process. Result is a tree of processes e.g. UNIX - processes have dependencies and form a hierarchy. Resources required when creating process CPU time, files, memory, I/O devices etc. init pid = 1 login pid = 8415 kthreadd pid = 2 sshd pid = 3028 bash pid = 8416 khelper pid = 6 pdflush pid = 200 sshd pid = 3610 ps pid = 9298 emacs pid = 9204 tcsch pid =

11 Process Termination Process executes last statement and asks the operating system to delete it (exit). Output data from child to parent (via wait). Process resources are deallocated by operating system. Parent may terminate execution of child processes. Child has exceeded allocated resources. Task assigned to child is no longer required. Parent is exiting» OS does not allow child to continue if parent terminates» Cascading termination 11 11

12 Threads Processes do not share resources well high context switching overhead A thread (or lightweight process) basic unit of CPU utilization; it consists of: program counter, register set and stack space A thread shares the following with peer threads: code section, data section and OS resources (open files, signals) Collectively called a task. Heavyweight process is a task with one thread. Thread support in modern systems User threads vs. kernel threads, lightweight processes 1-1, many-1 and many-many mapping Implicit Threading (e.g. OpenMP 12 12

13 Producer-Consumer Problem Paradigm for cooperating processes; producer process produces information that is consumed by a consumer process. We need buffer of items that can be filled by producer and emptied by consumer. Unbounded-buffer Bounded-buffer Producer and Consumer must synchronize. Out In

14 Interprocess Communication (IPC) Mechanism for processes to communicate and synchronize their actions. Via shared memory Via Messaging system - processes communicate without resorting to shared variables. Messaging system and shared memory not mutually exclusive -» can be used simultaneously within a single OS or a single process. IPC facility provides two operations.» send(message) - message size can be fixed or variable» receive(message) Direct vs. Indirect communication

15 Ordinary Pipes Pipe is a special type of file. Inherited by the child Must close unused portions of the the pipe 15

16 Scheduling Objectives Levels of Scheduling Scheduling Criteria Scheduling Algorithms Multiple Processor Scheduling Real-time Scheduling (skip) CPU Scheduling 16 16

17 Scheduling Criteria CPU utilization keep the CPU as busy as possible: Maximize Throughput # of processes that complete their execution per time unit: Maximize Turnaround time time to execute a process from submission to completion: Minimize Waiting time amount of time a process has been waiting in the ready queue: Minimize Response time time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment): Minimize 17

18 Scheduling Policies FCFS (First Come First Serve) Process that requests the CPU FIRST is allocated the CPU FIRST. SJF (Shortest Job First) Associate with each process the length of its next CPU burst. Use these lengths to schedule the process with the shortest time. Priority A priority value (integer) is associated with each process. CPU allocated to process with highest priority. Round Robin Each process gets a small unit of CPU time MultiLevel ready queue partitioned into separate queues Variation: Multilevel Feedback queues

19 All arrive at time 0. SJF scheduling chart Example of SJF ProcessArriva l TimeBurst Time P P P P P 4 P 1 P 3 P Average waiting time for P 1,P 2,P 3,P 4 = ( ) / 4 = 7 19

20 Determining Length of Next CPU Burst Can be done by using the length of previous CPU bursts, using exponential averaging 1. t n actual length of n 2. n 1 predicted value for the next CPU burst Commonly, α set to ½ th CPU burst 3., Define : n 1 tn n 1. 20

21 Multiple-Processor Scheduling CPU scheduling more complex when multiple CPUs are available. Assume Homogeneous processors within a multiprocessor Asymmetric multiprocessing only one processor accesses the system data structures, alleviating the need for data sharing Symmetric multiprocessing (SMP) each processor is self-scheduling, all processes in common ready queue, or each has its own private queue of ready processes Currently, most common Processor affinity process has affinity for processor on which it is currently running because of info in cache soft affinity: try but no guarantee hard affinity can specify processor sets 21

22 Multiple-Processor Scheduling Load Balancing If SMP, need to keep all CPUs loaded for efficiency Load balancing attempts to keep workload evenly distributed Push migration periodic task checks load on each processor, and if found pushes task from overloaded CPU to other CPUs Pull migration idle processors pulls waiting task from busy processor Combination of push/pull may be used. 22

23 Multithreaded Multicore System This is temporal multithreading. Simultaneous multithreading allows threads to computer in parallel 23

24 24 Evaluation of CPU Schedulers by Simulation

25 Process Synchronization The Critical Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization (partly) Monitors ( to come) 25 25

26 Consumer-producer problem Producer while (true) { /* produce an item*/ } while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; Consumer while (true) { while (counter == 0); /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZ counter--; /* consume the item in next consumed */ } They run concurrently (or in parallel), and are subject to context switches at unpredictable times

27 Race Condition counter++ could be compiled as register1 = counter register1 = register1 + 1 counter = register1 counter-- could be compiled as register2 = counter register2 = register2-1 counter = register2 They run concurrently, and are subject to context switches at unpredictable times. Consider this execution interleaving with count = 5 initially: S0: producer execute register1 = counter {register1 = 5} S1: producer execute register1 = register1 + 1 {register1 = 6} S2: consumer execute register2 = counter {register2 = 5} S3: consumer execute register2 = register2 1 {register2 = 4} S4: producer execute counter = register1 {counter = 6 } S5: consumer execute counter = register2 {counter = 4} 27 Overwrites!

28 The Critical Section Problem Requirements Mutual Exclusion Progress Bounded Waiting Solution to the critical section problem do { acquire lock critical section release lock remainder section } while (TRUE); 28 28

29 Solution using test_and_set() Shared Boolean variable lock, initialized to FALSE Solution: do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */.. lock = false; /* remainder section */.. } while (true); 29

30 Solution using compare_and_swap Shared integer lock initialized to 0; Solution: do { while (compare_and_swap(&lock, 0, 1)!= 0) ; /* do nothing */ /* critical section */ lock = 0; /* remainder section */ } while (true); Does not guarantee bounded waiting. 30

31 Semaphore Synchronization tool that provides more sophisticated ways (than Mutex locks) for process to synchronize their activities. Semaphore S integer variable Can only be accessed via two indivisible (atomic) operations wait() and signal() Originally called P() and V() Definition of the wait() operation wait(s) { while (S <= 0) ; // busy wait S--; } Definition of the signal() operation signal(s) { S++; } 31

32 Implementation with no Busy waiting (Counting Sema) wait(semaphore *S) { } S->value--; if (S->value < 0) { add this process to S->list; } block(); signal(semaphore *S) { } S->value++; if (S->value <= 0) { remove a process P from S->list; } wakeup(p); typedef struct{ int value; struct process *list; } semaphore; 32

33 Bounded Buffer Problem (Cont.) The structure of the producer process do {... /* produce an item in next_produced */... wait(empty); wait(mutex);... /* add next produced to the buffer */... signal(mutex); signal(full); } while (true); The structure of the consumer process Do { wait(full); wait(mutex);... /* remove an item from buffer to next_consumed */... signal(mutex); signal(empty);... /* consume the item in next consumed */... } while (true); 33