OS Midterm

small fast data storage location on the CPU (aka buffer register)

specifies the address in memory for the next read or write

holds address of next instruction to be fetched

stores the fetched instruction

allows other modules to interrupt the normal sequencing of the processor

fraction of all memory accesses found in the cache

memory references by processor tend to cluster.

limited range of memory addresses requested repeatedly over a period of time

memory addresses that are requested sequentially

small, quick access storage close to the CPU used for repetitively accessed data or instructions. Modernly stored in 3 levels (L1, L2, L3)

system of memory levels balancing cost and capacity vs speed. Bigger = slower = cheaper

memory that will be cleared when computer is powered off (ex: RAM)

helpful for handling asynchronous events, multitasking, and error handling

program (illegal instruction)

timer

I/O

hardware failure

determines nature of interrupt and performs necessary actions

program is able to execute separate instructions when waiting on something (like I/O)

Approach 1: Disable interrupts while processing an interrupt

Approach 2: Use a priority scheme

Ts = H*T1 + (1-H)*(T1 + T2)

where

Ts = average access time

H = hit ratio

T1 = access time of M1 (cache)

T2 = access time of M2 (main memory)

fetch instruction, then execute

interface between applications and hardware that controls the execution of programs

• processor

• I/O modules

• Main memory

• System Bus

provides communication between computer components

move data between computer and external environment

• secondary memory

• communication equipment

• terminal

I/O module performs action and sets appropriate bits in I/O status register. processor periodically checks status of I/O module

I/O module interrupts processor when ready to exchange data

performed by separate module on system bus or incorporated into I/O module

stand-alone computer system where

• 2+ processors

• processors share memory, access to I/O

• system controlled by one OS

• high performance/scaling/availability

contains the most frequently used OS instructions and other portions. The central component of the OS. Manages resources, processes, and memory

total time to execute a process

switching between processes, requires switching data within registers (aka context switch)

Instance of a program in execution; unit of activity that can be executed on a processor

• executable program

• associated data needed by program

• execution context

• internal data OS can supervise/control

• contents of registers

• process state, priority, I/O wait status

• process isolation

• automatic allocation + management

• modular programming support

• protection and access control

• long-term storage

how compiler builds an application. Defines system call interface through user Instruction set architecture (ISA)

Contains set of executable instructions by CPU. Considered an interface

a lightweight process that shares resources within a process. Dispatchable unit of work; includes a thread context

process which can separate concurrent threads

the ability to store processes in memory and switch execution between programs

number of concurrent processes allowed in main memory

convenience

efficiency

evolution ability

manage computer resources

multitasking executes multiple processes on one CPU by allocating each process CPU time. Parallel processing involves using multiple cores.

creation, execution, scheduling, resource management

allocated space for a program that has relative memory addresses

system of fixed size blocks assigned to processes

assigns few essential functions to kernel

• simple implementation

• flexible

• good for distributed environment

smaller than monolithic kernels

kernel where all components are in 1 address space. large and hard to design, but high performing

mechanism to send message kernel→process

mechanism to send message process→kernel

provide illusion of

• single main and secondary memory space

• unified access facilities

• add modular extensions to small kernel

• easy OS customizability

• eases development of tools

• new

• ready

• running

• blocked

• exiting

Blocked

• waiting on event

• can run once event happens

Suspended

• able to run

• instructed not to run

moving pages from memory to disk

• happens when OS runs out of physical memory

small program that switches processor between processes

queue that stores processes ready to run (waiting for CPU time)

queue that manages and processes asynchronous events (ex: timers, I/O)

dedicate 1 or more cores to a particular process and leave processor alone

suspending a running process to allow another process to run

7 step execution to switch processes

• save processor context

• update PCB

• move PCB to appropriate queue

• select new process

• update PCB

• update memory data structures

• restore processor context

process’s state at a given moment

• user-level context

• register context

• system level context

data needed by OS to control process

• identifiers

• user-visible registers

• control and status register

• scheduling

• privileges

• resources

• memory management

• contain info about process

• read/modified by every module in OS

• defines state of OS

hard to protect

Executing in user mode

Executing in kernel mode

ready to run as soon as the kernel schedules it

unable to run until event occurs; process in main memory (blocked state)

ready to run, but must be swapped into main memory

process awaiting event and swapped into secondary storage (blocked state)

able to run, but instructed not to. Process returning from kernel mode to user mode, kernel does process switch to switch to other process

process newly created; not ready to run. Parent has signaled desire for child but child is not allocated space nor in main memory yet

process DNE, but leaves record for parent process to collect

processes that spend a significant amount of time waiting for I/O responses

processes that spend almost all of their time in CPU time

user mode requests services from OS through system calls and interrupts

• protection

• security

• isolation

• flexibility

applications act in user mode, until they need special access through system calls and interrupts

• assign PID

• allocate space

• initialize PCB

• set linkages

• create/expand other data structures

error generated by current process

known as exception/fault

• timeout

• I/O

• system calls

• interrupts

• thread management done by application

• kernel not aware of threads

thread management done by kernel

threads share memory, are quicker, more efficient

• execution state

• thread context

• execution stack

• storage

• memory/resource access

• ready

• running

• blocked

• spawn

• block

• unblock

• finish

pros:

• doesn’t require kernel mode

• works on any OS

cons:

• system calls block all threads of a process

• cannot multiprocess

pros:

• can run multiple threads in parallel

• can schedule new thread if thread is blocked

cons:

• needs kernel mode

• OS specific

ULT: web servers, games, user level applications

KLT: network services, device drivers, background applications

User: most applications run here, restricted access, safer

Kernel: unrestricted access, dangerous

the idea that speedup has diminishing returns and does not scale linearly. Allows us to determine optimal number of processors

• single-threaded process

• thread

• kernel tasks

separate views that process can have of the system

• helps create illusion that processes are the only process on a system

easier to control semaphore implemented at the PL level

enforce mutual exclusion

achieved by condition variables

• binary variables that flag suspension or resumption of a process

needs synchronization and communication

has send and receive

both sender and receiver can be blocked

schemes for specifying processes in send and receive

direct and indirect

data area shared among many processes

3 conditions

• any number of readers

• 1 writer

• no reading when writer writing

when multiple threads/processes read and write data items; final result depends on order of execution

requirement that no other processes can be in a critical section when 1 process is accessing critical resources