Operating Systems flashcards, generated for you.

Software that manages hardware resources and provides services to applications. Acts as intermediary between users/programs and physical hardware (CPU, memory, disk, I/O devices).

Preemptive: OS can interrupt a running process and switch to another (higher priority). Non-preemptive: process runs until completion or voluntary yield. Preemptive ensures responsiveness but adds context-switch overhead.

Switching CPU execution from one process to another. Costs: saving/restoring registers and memory state, cache misses (TLB/L1/L2), lost CPU cycles. Higher frequency reduces responsiveness but hurts throughput.

Excessive page faults where OS spends more time swapping pages between RAM and disk than executing user code. Occurs when working set exceeds physical memory. Severely degrades performance.

Fairness: equal CPU time to all processes (round-robin). Efficiency: maximize CPU utilization and throughput (FCFS, SJF). Fair scheduling increases context switches (overhead); efficient scheduling may starve low-priority tasks.

Critical section: code where process accesses shared resource requiring mutual exclusion. Locks ensure only one process enters at a time, but circular wait for multiple locks (A holds lock1, waits lock2; B holds lock2, waits lock1) causes deadlock.

Blocking: process waits (sleeps) until I/O completes, wasting CPU time but simpler. Non-blocking: process continues; OS notifies via callback/event when I/O done, higher throughput but complex. Trade-off: simplicity vs. resource utilization.

Delays copying memory until a write occurs. Parent and child processes share read-only pages initially; only modified pages are copied. Reduces memory usage and fork() latency; costs: page fault overhead on first write, complexity.

Large pages: fewer TLB misses, lower page table overhead, simpler. Small pages: better granularity, less internal fragmentation, fit working set better. Larger pages reduce miss rate but increase memory waste; smaller pages increase TLB misses.

Isolation: separate address spaces, privilege levels, context switches prevent interference but add overhead (syscall cost, TLB flushes, privilege transitions). Performance: shared resources, direct memory access are faster but expose security/stability risks. Kernel must balance security enforcement with minimal latency tax.