Cs 4410 review
This presentation is the property of its rightful owner.
Sponsored Links
1 / 55

CS 4410 Review PowerPoint PPT Presentation


  • 106 Views
  • Uploaded on
  • Presentation posted in: General

CS 4410 Review. Announcements. Homework 6 Due today, Tuesday, December 2 nd See me after class to pick up prelim II Upcoming Agenda This week is last week of classes—December 2 nd and 4 th Final—Thursday, December 18 th at 2pm Room 131 Warren Hall Length is 2 ½ hrs

Download Presentation

CS 4410 Review

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Cs 4410 review

CS 4410 Review


Announcements

Announcements

  • Homework 6 Due today, Tuesday, December 2nd

  • See me after class to pick up prelim II

  • Upcoming Agenda

    • This week is last week of classes—December 2nd and 4th

    • Final—Thursday, December 18th at 2pm

      • Room 131 Warren Hall

      • Length is 2 ½ hrs

    • Email to confirm office hours


Goals for today

Goals for Today

  • Review half the book

    • Make sure intuition is clear

    • Ask questions

  • For more detailed information

    • Use past slides, “redo” homework and prelims


Operating system definition

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

Physical machine interface

Hardware

Advantages

Easy to use, simpler to code, more reliable, more secure, …

You can say: “I want to write XYZ into file ABC”


What is in an os

What is in an OS?

Quake

Sql Server

Applications

Windowing & graphics

System Utils

Shells

OS Interface

Naming

Windowing & Gfx

Operating System Services

Networking

Virtual Memory

Access Control

Generic I/O

File System

Process Management

Device Drivers

Memory Management

Physical m/c Intf

Interrupts, Cache, Physical Memory, TLB, Hardware Devices

Logical OS Structure


Crossing protection boundaries

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 Mode

Mode bit = 1

Resume process

User process

System Call

Trap

Mode bit = 0

Kernel Mode

Mode bit = 0

Return

Mode bit = 1

Save Caller’s state

Execute system call

Restore state


What is a process

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”


Process state transitions

Process State Transitions

interrupt

New

Exit

admitted

done

Ready

dispatch

Running

I/O or event

completion

I/O or event wait

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


Context switch

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


Threads and processes

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


Schedulers

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


Cpu scheduling algorithms

CPU Scheduling Algorithms

  • FCFS

  • LIFO

  • SJF

  • SRTF

  • Priority Scheduling

  • Round Robin

  • Multi-level Queue

  • Multi-level Feedback Queue


Cpu scheduling metrics

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


Race conditions

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


The fundamental issue atomicity

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


Critical section problem

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?

CS1

Process 1

Process 2

CS2

Time 

Processes progress with non-zero speed, no assumption on clock speed

Used extensively in operating systems:

Queues, shared variables, interrupt handlers, etc.


Solution structure

Solution Structure

Shared vars:

Initialization:

Process:

. . .

. . .

Entry Section

Critical Section

Exit Section

Added to solve the CS problem


Solution requirements

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, …


Semaphores

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++;

}


Semaphore types

Semaphore Types

  • Counting Semaphores:

    • Any integer

    • Used for synchronization

  • Binary Semaphores

    • Value 0 or 1

    • Used for mutual exclusion (mutex)

Process i

P(S);

Critical Section

V(S);

Shared: semaphore S

Init: S = 1;


Mutexes and synchronization

Deadlock

Mutexes and Synchronization

semaphore S;

P(S) {

while(S ≤ 0)

;

S--;

}

Init: S = 1;

Init: S = 0;

Process i

P(S);

Code XYZ

V(S);

Process j

P(S);

Code ABC

V(S);

V(S) {

S++;

}


Monitors

Monitors

  • Hoare 1974

  • Abstract Data Type for handling/defining shared resources

  • Comprises:

    • Shared Private Data

      • The resource

      • Cannot be accessed from outside

    • Procedures that operate on the data

      • Gateway to the resource

      • Can only act on data local to the monitor

    • Synchronization primitives

      • Among threads that access the procedures


Synchronization using monitors

Synchronization Using Monitors

  • Defines Condition Variables:

    • condition x;

    • Provides a mechanism to wait for events

      • Resources available, any writers

  • 3 atomic operations on Condition Variables

    • x.wait(): release monitor lock, sleep until woken up

       condition variables have waiting queues too

    • x.notify(): wake one process waiting on condition (if there is one)

      • No history associated with signal

    • x.broadcast(): wake all processes waiting on condition

      • Useful for resource manager

  • Condition variables are not Boolean

    • If(x) then { } does not make sense


Types of monitors

Types of Monitors

What happens on notify():

  • Hoare: signaler immediately gives lock to waiter (theory)

    • Condition definitely holds when waiter returns

    • Easy to reason about the program

  • Mesa: signaler keeps lock and processor (practice)

    • Condition might not hold when waiter returns

    • Fewer context switches, easy to support broadcast

  • Brinch Hansen: signaler must immediately exit monitor

    • So, notify should be last statement of monitor procedure


Deadlocks

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


Four conditions for deadlock

Four Conditions for Deadlock

  • Coffman et. al. 1971

  • 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 {P1, P2, … PN}, such that

        • P1 is waiting for P2, P2 for P3, …. and PN for P1

          All four conditions must hold for deadlock to occur


Dealing with deadlocks

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


Safe state

Safe State

  • A state is said to be safe, if it has a process sequence

    {P1, P2,…, Pn}, such that for each Pi,

    the resources that Pi can still request can be satisfied by the currently available resources plus the resources held by all Pj, 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


Banker s algorithm

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


Basic algorithm

Basic Algorithm

  • If request[i] > need[i] then

    error (asked for too much)

  • If request[i] > available then

    wait (can’t supply it now)

  • 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.


Memory management issues

gcc

Memory Management Issues

  • Protection: Errors in process should not affect others

  • Transparency: Should run despite memory size/location

Translation box (MMU)

legal addr?

Illegal?

Physical

address

Load Store

Physical

memory

virtual

address

CPU

fault

data

How to do this mapping?


Scheme 1 load time linking

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)

  • Issues: handling multiple segments, moving in memory

OS

static a.out

0x3000

0x6000

jump 0x2000

jump 0x2000

jump 0x5000

0x4000

0x1000


Scheme 2 execution time linking

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?

    • When process runs, base register = 0x3000, bounds register = 0x2000. Jump addr = 0x2000 + 0x3000 = 0x5000

OS

a.out

0x6000

0x3000

MMU

a.out

Base: 0x3000

Limit: 0x2000

jump 0x2000

jump 0x2000

0x4000

0x1000


Segmentation

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

Real memory

gcc

0x1000

0x3000

0x5000

0x6000

0x2000

0x8000

0x6000

Text seg

r/o

Base&Limit?

Stack seg

r/w

How to do the mapping?


Mapping segments

fault

Virtual addr

no

mem

yes

Seg table

?

3 128

+

0x1000

Prot base len

Seg#offset

128

seg

r 0x1000 512

Mapping Segments

  • Segment Table

    • An entry for each segment

    • Is a tuple <base, limit, protection>

  • Each memory reference indicates segment and offset


Fragmentation

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

External

fragmentation

gcc

Word

??

emacs

Unused

(“internal

fragmentation”)

allocated

stack

doom


Paging

Paging

  • Divide memory into fixed size pieces

    • Called “frames” or “pages”

  • Pros: easy, no external fragmentation

Pages

typical: 4k-8k

gcc

emacs

internal frag


Mapping pages

Mapping Pages

  • If 2m virtual address space, 2n page size

    • (m - n) bits to denote page number, n for offset within page

      Translation done using a Page Table

Virtual addr

mem

((1<<12)|128)

3 128 (12bits)

0x1000

VPN page offset

128

page table

seg

Prot VPN PPN

?

PPN

“invalid”

r 3 1


Paging segmentation

Seg #page # (8 bits)page offset (12 bits)

(4 bits)

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)


What is virtual memory

disk

page table

Physical memory

What is virtual memory?

  • Each process has illusion of large address space

    • 232 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


Virtual memory

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)


Page faults

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


Page replacement algorithms

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. 0 1 2 3 0 1 4 0 1 2 3 4 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


Thrashing

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


Approach 1 working set

Approach 1: Working Set

  • Peter Denning, 1968

    • Defines the locality of a program

      pages referenced by process in last T seconds of execution considered to comprise its working set

      T: the working set parameter

  • Uses:

    • Caching: size of cache is size of WS

    • Scheduling: schedule process only if WS in memory

    • Page replacement: replace non-WS pages


Working sets

Working Sets

  • The working set size is num pages in the working set

    • the number of pages touched in the interval (t, t-Δ).

  • The working set size changes with program locality.

    • during periods of poor locality, you reference more pages.

    • Within that period of time, you will have a larger working set size.

  • Don’t run process unless working set is in memory.


Approach 2 page fault frequency

Approach 2: Page Fault Frequency

  • thrashing viewed as poor ratio of fetch to work

  • PFF = page faults / instructions executed

  • if PFF rises above threshold, process needs more memory

    • not enough memory on the system? Swap out.

  • if PFF sinks below threshold, memory can be taken away


Allocation and deallocation

Allocation and deallocation

  • What happens when you call:

    • int *p = (int *)malloc(2500*sizeof(int));

      • Allocator slices a chunk of the heap and gives it to the program

    • free(p);

      • Deallocator will put back the allocated space to a free list

  • Simplest implementation:

    • Allocation: increment pointer on every allocation

    • Deallocation: no-op

    • Problems: lots of fragmentation

heap (free memory)

allocation

current free position


Memory allocator

20

20

10

20

10

Memory Allocator

  • What allocator has to do:

    • Maintain free list, and grant memory to requests

    • Ideal: no fragmentation and no wasted time

  • What allocator cannot do:

    • Control order of memory requests and frees

    • A bad placement cannot be revoked

  • Main challenge: avoid fragmentation

a

b

malloc(20)?


What happens on free

What happens on free?

  • Identify size of chunk returned by user

  • Change sign on both signatures (make +ve)

  • Combine free adjacent chunks into bigger chunk

    • Worst case when there is one free chunk before and after

    • Recalculate size of new free chunk

    • Update the signatures

  • Don’t really need to erase old signatures


Example

+8

+8

-2

-2

+4

+4

Example

Initially one chunk, split and make signs negative on malloc

p = malloc(2 * sizeof (int));


Example1

+8

+8

-2

-2

-4

-4

Example

q gets 4 words, although it requested for 3

q = malloc(3 * sizeof (int));

p = malloc(2 * sizeof (int));


Design features

30

20

10

30

30

Design features

  • Which free chunks should service request

    • Ideally avoid fragmentation… requires future knowledge

  • Split free chunks to satisfy smaller requests

    • Avoids internal fragmentation

  • Coalesce free blocks to form larger chunks

    • Avoids external fragmentation


Malloc os memory management

Malloc & OS memory management

  • Relocation

    • OS allows easy relocation (change page table)

    • Placement decisions permanent at user level

  • Size and distribution

    • OS: small number of large objects

    • Malloc: huge number of small objects

heap

stack

data

code


Hand back prelims

Hand back prelims


  • Login