Review Yi Shi Fall Xi an Jiaotong University

Transcription

1 Review Yi Shi Fall 2017 Xi an Jiaotong University

2 Operating System: Definition Definition An Operating System (OS) provides a virtual machine on top of the real hardware, whose interface is more convenient than the raw hardware interface. Applications OS interface Operating System Hardware Physical machine interface Advantages Easy to use, simpler to code, more reliable, more secure, You can say: I want to write XYZ into file ABC 2

3 Crossing Protection Boundaries User calls OS procedure for privileged operations Calling a kernel mode service from user mode program: Using System Calls System Calls switches execution to kernel mode User process System Call User Mode Mode bit = 1 Resume process Trap Mode bit = 0 Kernel Mode Mode bit = 0 Return Mode bit = 1 Save Caller s state Execute system call Restore state 3

4 What is a process? The unit of execution The unit of scheduling Thread of execution + address space Is a program in execution Sequential, instruction-at-a-time execution of a program. The same as job or task or sequential process 4

5 Process State Transitions interrupt New Ready dispatch Running Exit Waiting Processes hop across states as a result of: Actions they perform, e.g. system calls Actions performed by OS, e.g. rescheduling External actions, e.g. I/O 5

6 Context Switch For a running process All registers are loaded in CPU and modified E.g. Program Counter, Stack Pointer, General Purpose Registers When process relinquishes the CPU, the OS Saves register values to the PCB of that process To execute another process, the OS Loads register values from PCB of that process Context Switch Process of switching CPU from one process to another Very machine dependent for types of registers 6

7 Threads and Processes Most operating systems therefore support two entities: the process, which defines the address space and general process attributes the thread, which defines a sequential execution stream within a process A thread is bound to a single process. For each process, however, there may be many threads. Threads are the unit of scheduling Processes are containers in which threads execute 7

8 IPC Independent vs Cooperating processes Why let processes cooperate? Information sharing Computation speedup Modularity Convenience: a user may work on many tasks Cooperating processes need IPC Two fundamental models Message Passing: easier, smaller amounts of data, slower Shared Memory: harder, large amounts of data, maximum speed

9 Schedulers Process migrates among several queues Device queue, job queue, ready queue Scheduler selects a process to run from these queues Long-term scheduler: load a job in memory Runs infrequently Short-term scheduler: Select ready process to run on CPU Should be fast Middle-term scheduler Reduce multiprogramming or memory consumption 9

10 CPU Scheduling Algorithms FCFS SJF Priority Scheduling Round Robin Multi-level Queue Multi-level Feedback Queue 10

11 CPU Scheduling Metrics CPU utilization: percentage of time the CPU is not idle Throughput: completed processes per time unit Turnaround time: submission to completion Waiting time: time spent on the ready queue Response time: response latency 11

12 Race conditions Definition: timing dependent error involving shared state Whether it happens depends on how threads scheduled Hard to detect: All possible schedules have to be safe Number of possible schedule permutations is huge Some bad schedules? Some that will work sometimes? they are intermittent Timing dependent = small changes can hide bug

13 The Fundamental Issue: Atomicity Our atomic operation is not done atomically by machine E.g. incrementing a variable by one (i++) is three machine instructions (load, increment, store). Process can be interrupted between any machine instruction Atomic Unit: instruction sequence guaranteed to execute indivisibly Also called critical section (CS) When 2 processes want to execute their Critical Section, One process finishes its CS before other is allowed to enter 13

14 Critical Section Problem Problem: Design a protocol for processes to cooperate, such that only one process is in its critical section How to make multiple instructions seem like one? Process 1 CS 1 Process 2 CS 2 Time Processes progress with non-zero speed, no assumption on clock speed Used extensively in operating systems: Queues, shared variables, interrupt handlers, etc. 14

15 Shared vars: Initialization: Process: Solution Structure Entry Section Critical Section Added to solve the CS problem Exit Section 15

16 Solution Requirements Mutual Exclusion Only one process can be in the critical section at any time Progress Decision on who enters CS cannot be indefinitely postponed No deadlock Bounded Waiting Bound on #times others can enter CS, while I am waiting No livelock Also efficient (no extra resources), fair, simple, 16

17 Semaphores Non-negative integer with atomic increment and decrement Integer S that (besides init) can only be modified by: P(S) or S.wait(): decrement or block if already 0 V(S) or S.signal(): increment and wake up process if any These operations are atomic semaphore S; P(S) { while(s 0) ; S--; } V(S) { S++; } 17

18 Semaphore Types Counting Semaphores: Any integer Used for synchronization Binary Semaphores Value 0 or 1 Used for mutual exclusion (mutex) Process i Shared: semaphore S Init: S = 1; P(S); Critical Section V(S); 18

19 Mutexes and Synchronization semaphore S; Init: S = 0; 1; Deadlock P(S) { while(s 0) ; S--; } V(S) { S++; } Process i P(S); Code XYZ V(S); Process j P(S); Code ABC V(S); 19

20 Deadlocks Definition: Deadlock exists among a set of processes if Every process is waiting for an event This event can be caused only by another process in the set Event is the acquire of release of another resource One-lane bridge 20

21 Four Conditions for Deadlock Coffman et. al Necessary conditions for deadlock to exist: Mutual Exclusion At least one resource must be held is in non-sharable mode Hold and wait There exists a process holding a resource, and waiting for another No preemption Resources cannot be preempted Circular wait There exists a set of processes {P 1, P 2, P N }, such that P 1 is waiting for P 2, P 2 for P 3,. and P N for P 1 All four conditions must hold for deadlock to occur 21

22 Dealing with Deadlocks Proactive Approaches: Deadlock Prevention Negate one of 4 necessary conditions Prevent deadlock from occurring Deadlock Avoidance Carefully allocate resources based on future knowledge Deadlocks are prevented Reactive Approach: Deadlock detection and recovery Let deadlock happen, then detect and recover from it Ignore the problem Pretend deadlocks will never occur Ostrich approach 22

23 Safe State A state is said to be safe, if it has a process sequence {P 1, P 2,, P n }, such that for each P i, the resources that P i can still request can be satisfied by the currently available resources plus the resources held by all P j, where j < i State is safe because OS can definitely avoid deadlock by blocking any new requests until safe order is executed This avoids circular wait condition Process waits until safe state is guaranteed 23

24 Banker s Algorithm Decides whether to grant a resource request. Data structures: n: integer # of processes m: integer # of resources available[1..m] available[i] is # of avail resources of type i max[1..n,1..m] max demand of each Pi for each Ri allocation[1..n,1..m] current allocation of resource Rj to Pi need[1..n,1..m] max # resource Rj that Pi may still request let request[i] be vector of # of resource Rj Process Pi wants 24

25 Basic Algorithm 1. If request[i] > need[i] then error (asked for too much) 2. If request[i] > available then wait (can t supply it now) 3. Resources are available to satisfy the request Let s assume that we satisfy the request. Then we would have: available = available - request[i] allocation[i] = allocation [i] + request[i] need[i] = need [i] - request [i] Now, check if this would leave us in a safe state: if yes, grant the request, if no, then leave the state as is and cause process to wait. 25

26 Memory Management Issues Protection: Errors in process should not affect others Transparency: Should run despite memory size/location gcc Load Store CPU Translation box (MMU) virtual address data fault legal addr? Illegal? Physical address Physical memory How to do this mapping? 26

27 Scheme 1: Load-time Linking Link as usual, but keep list of references At load time: determine the new base address Accordingly adjust all references (addition) static a.out 0x3000 OS 0x6000 jump 0x2000 0x1000 jump 0x5000 0x4000 Issues: unused routine is linked and loaded, moving in memory 27

28 Scheme 2: Execution-time Linking Use hardware (base + limit reg) to solve the problem Done for every memory access Relocation: physical address = logical (virtual) address + base Protection: is virtual address < limit? a.out jump 0x2000 0x3000 0x1000 MMU Base: 0x3000 Limit: 0x2000 OS a.out jump 0x2000 0x6000 0x4000 When process runs, base register = 0x3000, bounds register = 0x2000. Jump addr = 0x x3000 = 0x

29 Segmentation Processes have multiple base + limit registers Processes address space has multiple segments Each segment has its own base + limit registers Add protection bits to every segment 0x1000 0x3000 gcc Text seg r/o Real memory 0x2000 0x5000 0x6000 Stack seg r/w Base&Limit? 0x8000 0x6000 How to do the mapping? 29

30 Mapping Segments Segment Table An entry for each segment Is a tuple <base, limit, protection> Each memory reference indicates segment and offset fault Virtual addr no 3 128? yes Seg# offset Seg table Prot base len + 0x1000 seg mem 128 r 0x

31 Fragmentation The inability to use free memory External Fragmentation: Variable sized pieces many small holes over time Internal Fragmentation: Fixed sized pieces internal waste if entire piece is not used Word?? gcc emacs External fragmentation allocated stack doom Unused ( internal fragmentation ) 31

32 Paging Divide memory into fixed size pieces Called frames or pages Pros: easy, no external fragmentation Pages typical: 4k-8k gcc emacs internal frag 32

33 Mapping Pages If 2 m virtual address space, 2 n page size (m - n) bits to denote page number, n for offset within page Translation done using a Page Table Virtual addr (12bits) ((1<<12) 128) 0x1000 mem VPN page offsetpage table Prot VPN PPN? PPN seg 128 invalid r

34 Paging Hardware With TLB 页表寄存器 页表始址页表长度 页号 块号 页表 越界中断 > = 输入寄存逻辑地址寄存器 页号 页内地址 快表 块号 块内地址 物理地址寄存器

35 Paging + Segmentation Paged segmentation Handles very long segments The segments are paged Segmented Paging When the page table is very big Segment the page table Let s consider System 370 (24-bit address space) Seg #page # (8 bits) (4 bits) page offset (12 bits) 35

36 What is virtual memory? Each process has illusion of large address space 2 32 for 32-bit addressing However, physical memory is much smaller How do we give this illusion to multiple processes? Virtual Memory: some addresses reside in disk page table disk Physical memory 36

37 Virtual Memory Load entire process in memory (swapping), run it, exit Is slow (for big processes) Wasteful (might not require everything) Solutions: partial residency Paging: only bring in pages, not all pages of process Demand paging: bring only pages that are required Where to fetch page from? Have a contiguous space in disk: swap file (pagefile.sys) 37

38 Page Faults On a page fault: OS finds a free frame, or evicts one from memory (which one?) Want knowledge of the future? Issues disk request to fetch data for page (what to fetch?) Just the requested page, or more? Block current process, context switch to new process (how?) Process might be executing an instruction When disk completes, set present bit to 1, and current process in ready queue 38

39 Page Replacement Algorithms Random: Pick any page to eject at random Used mainly for comparison FIFO: The page brought in earliest is evicted Ignores usage Suffers from Belady s Anomaly Fault rate could increase on increasing number of pages E.g with frame sizes 3 and 4 OPT: Belady s algorithm Select page not used for longest time LRU: Evict page that hasn t been used the longest Past could be a good predictor of the future 39

40 Thrashing Processes in system require more memory than is there Keep throwing out page that will be referenced soon So, they keep accessing memory that is not there Why does it occur? No good reuse, past!= future There is reuse, but process does not fit Too many processes in the system 40

41 File System File System: Layer of OS that transforms block interface of disks (or other block devices) into Files, Directories, etc. File System Components Disk Management: collecting disk blocks into files Naming: Interface to find files by name, not by blocks Protection: Layers to keep data secure Reliability/Durability: Keeping of files durable despite crashes, media failures, attacks, etc User vs. System View of a File User s view: Durable Data Structures System s view (system call interface): Collection of Bytes (UNIX) 41

42 File Operations File is an Abstract Data Type Some basic file operations: Create: find space in FS, add directory entry Write (e.g. write at current position) Read/write pointer can be stored as per-process file pointer Increase the size attribute Read (e.g. read from current position, store in buffer) Seek: move current position somewhere in a file Delete: Remove file from directory entry, mark 42

43 Implementing Files Contiguous Allocation: allocate files contiguously on disk 43

44 Linked List Allocation Each file is stored as linked list of blocks First word of each block points to next block Rest of disk block is file data 44

45 Using an in-memory table Implement a linked list allocation using a table Called File Allocation Table (FAT) Take pointer away from blocks, store in this table 45

46 I-nodes Index-node (I-node) is a per-file data structure Lists attributes and disk addresses of file s blocks Pros: Space (max open files * size per I-node) Cons: what if file expands beyond I-node address space? 46

47 Implementing Directories When a file is opened, OS uses path name to find dir Directory has information about the file s disk blocks Whole file (contiguous), first block (linked-list) or I-node Directory also has attributes of each file Directory: map ASCII file name to file attributes & location 2 options: entries have all attributes, or point to file I-node 47

48 Implementing Directories What if files have large, variable-length names? Solution: Limit file name length, say 255 chars, and use previous scheme Pros: Simple Cons: wastes space Directory entry comprises fixed and variable portion Fixed part starts with entry size, followed by attributes Variable part has the file name Pros: saves space Cons: holes on removal, page fault on file read, word boundaries Directory entries are fixed in length, pointer to file name in heap Pros: easy removal, no space wasted for word boundaries Cons: manage heap, page faults on file names 48

49 Managing Free Disk Space 2 approaches to keep track of free disk blocks Linked list and bitmap approach 49

50 Disk overheads To read from disk, we must specify: cylinder #, surface #, sector #, transfer size, memory address Transfer time includes: Seek time: to get to the track Latency time: to get to the sector and Transfer time: get bits off the disk Track Sector Seek Time Rotation Delay 50

51 Disk Scheduling FCFS SSTF SCAN C-SCAN LOOK C-LOOK 51

52 RAID Levels 0: Striping 1: Mirroring 2: Hamming Codes 3: Parity Bit 4: Block Striping 5: Spread parity blocks across all disks 0+1 and

53 That s it! Good luck and have a good break! 53