Use LEFT and RIGHT arrow keys to navigate between flashcards;
Use UP and DOWN arrow keys to flip the card;
H to show hint;
A reads text to speech;
32 Cards in this Set
- Front
- Back
|
Fixed Partitions |
- multiple partitions. Each can be assigned to a diff job - allows multiple jobs at the same time - partitions are static; entire system must be turned off to reconfigure size - internal fragmentation when partition is larger than job |
|
|
Dynamic Partitions |
- memory rationed to jobs in one continuous block. - each job given exact amount of memory needed - causes external fragmentation after jobs finish and new jobs enter system - when jobs are not the same size as previous, space is left |
|
|
Internal Fragmention |
Phenomenon of less than complete use of memory space in a fixed partition. |
|
|
External Fragmentation |
Subsequent allocation of memory in dynamic partitioning that creates fragments of free memory between partitions p allocated memory. |
|
|
Best Fit Allocation |
Organizes the free/busy lists in order by size - space is optimized - jobs put where they fit best - makes it easy to find smallest available empty space for job - disadvantage: wasting time looking for the best space |
|
|
First Fit Allocation |
Organizes free/busy lists by memory locations - optimizes the time it takes you to put jobs in storage - ignores job size and finds first empty space - disadvantage: space isn’t managed efficiently. Bad if space is limited - |
|
|
Paged Memory Allocation |
Based on the concept of dividing jobs into units of equal size. Each unit is called a page. - pages don’t have to be contiguous. Can be stored in any available page frame anywhere in memory |
|
|
Page frame |
A section of main memory that stores pages |
|
|
Page Displacement |
Distance a certain byte is form the beginning of its page frame. - the first byte of each page would have a displacement of 0. - if each page holds 100 bytes, bytes 0, 100, 200 & 300 would be the first bytes for pages 0-3, each having a displacement of 0. Each consecutive bytes displacement would increase by 1 |
|
|
Internal & External Fragmentation in Paged Memory Allocation |
External Fragmentation is eliminated because page frames don’t have to be contiguous Internal Fragmentation can occur in the last page frame of a job, when its bytes are not fully utilized |
|
|
Thrashing |
Problem that occurs as a result of excessive page swapping between main and secondary memory that makes the operation less efficient Caused when pages are frequently removed form memory but are called back shortly after Uses a great deal of the computers time but accomplished very little |
|
|
First In First Out |
Assumes that the best page to remove is the one that has been in memory the longest - removes pages that have been in memory the longest |
|
|
Failure Rate |
Failure rate = # of interrupts / page requests made |
|
|
Page Interrupt |
(*) generates anytime a page needs to be loaded into memory, whether it is swapped out or not |
|
|
Least Recently Used |
Chooses the page least recently accessed to be swapped out - |
|
|
Cache Memory |
- b/c it is small compared to main memory, can use more expensive memory chips - having any cache, even a smaller one, can improve computer performance - stores data that are frequently used, so memory access time is cut down |
|
|
Process States |
Hold, ready, running, waiting, finished |
|
|
First Come, First Served |
Nonpreemptive scheduling algorithm that handles objects according to arrival time
-uses a First in first out queue - each job is run to completion |
|
|
Shortest job next |
Nonpreemptive scheduling algorithm that chooses jobs based on the cpu cycle length |
|
|
Shortest Remaining Time |
Preemptive version of the SJN algorithm - processor is allocated to the job closest to completion - can be interrupted if a newer job in the ready queue has a shorter remaining time - if several jobs have same remaining time, job waiting the longest goes next |
|
|
Round Robin |
Based on a time quantum, a designated amount of time given to each job |
|
|
Multiple level queues |
Groups jobs into queues based on common characteristics. - flexible scheme, allows aging or other queue movement to counteract indefinite postponement |
|
|
Deadlock |
Problem that occurs when resources needed by some job are held by other jobs which are waiting for other resources to become available |
|
|
Necessary Conditions for Deadlock |
- Mutual exclusion: act of only allowing one process to have access to a resource at a time - resource holding: each process refuses to relinquish resources it holds until execution is completed - no preemption: a process is allowed to hold on to resources while it is waiting for other resources to finish execution - circular wait: each process involved is waiting for a resource being held by another. Each process is blocked and can’t continue |
|
|
Modeling Deadlocks |
Circle: represent processes Square: represents resources Solid line: indicates a process requested a resource and was granted it Dashed line: a process request for a resource that hasn’t been filled |
|
|
Strategies for Handling Deadlock: Preventions |
To prevent a Deadlock, the OS must eliminate one of the 4 necessary conditions |
|
|
Strategies for Handling Deadlock: Avoidance |
OS can avoid a Deadlock if it knows ahead of time the sequence of requests associated with each active process |
|
|
Strategies for Handling Deadlock: Detection |
Detect Deadlocks by building directed graphs and looking for cycles |
|
|
Strategies for Handling Deadlock: Recovery |
Recover Algorithm must untangle Deadlock and return system to normal as quickly as possible. - requires a victim - can terminate every job - can terminate only jobs involved in Deadlock - terminate deadlocked jobs one at a time |
|
|
Bankers algorithm |
Used to avoid Deadlocks in systems with a few resources Safe state: system had enough available resources to guarantee the completion of at least one job Unsafe state: system has too few resources to guarantee completion of at least one job |
|
|
Starvation |
When a single job is waiting for a resource that never becomes available |
|
|
Livelock |
A locked system where two or more processes continually block the progress of others while not making forward progress themselves |
