Understand Operating Systems Concepts

The operating system acts as a translator between applications and hardware, managing resources and enabling multitasking. Boots from drive to RAM, loads apps, and coordinates printing for smooth execution.

Explore monolithic and microkernel architectures, comparing kernel space and userspace, system calls, scheduling, and IPC, with Linux monolithic kernel as an example and drivers and file systems in kernel space.

A process is a running program; starting an app creates a process, and closing it kills that process. The processor can switch between processes, giving the illusion of parallel execution.

Explore how the operating system manages a process lifecycle through ready, running, and waiting states, schedules one processor at a time, handles input/output waits, and stores data during switches.

Deciding which process runs, the operating system scheduler aims for fast, fair decisions. It uses round-robin and priority with aging to prevent starvation and improve turnaround and response time.

Understand how threads execute code within a process, with their own registers and stacks, share resources, and enable faster context switching than processes. Compare library-based and kernel-based threads.

Explore unix process lifecycles and the kernel's role in scheduling and swapping. See how processes are created with fork and exec and how parent and child share data.

Understand Windows process states and thread scheduling, including initialization, ready, standby, running, waiting, and termination. Explore scheduling priorities, preemption, affinity masks, and the distinction between base and current priorities.

Delve into multiprocessing in operating systems, covering symmetric multiprocessing, the processor affinity mask, and how schedulers balance ideal and last processor assignment, preemption, and priorities.

Explore O(n) versus O(1) scheduling in Linux, a priority-based approach using active and expired run queues to manage real-time and normal processes, ensuring fairness and preventing starvation.

Explain completely fair scheduling used by Linux to give each process equal cpu time via a time slice, managed with a red-black tree and optional priority adjustments.

Explore how processes communicate through messages and shared memory, and learn how synchronization primitives and atomic operations prevent data races, using mutexes and critical sections.

Understand how a semaphore, a protected shared variable with a count, manages access to limited resources using atomic down (wait) and up (signal) operations to block and release threads.

Explain how a mutex enforces mutual exclusion for a critical section with enter and leave operations, using hardware or software support to ensure only one thread runs protected code.

Explore signals as a Unix/Linux synchronization primitive for inter-process communication, and compare them with Windows events, detailing event creation, waiting, signaling, initial state, cross-process sharing, and signal handlers.

Monitors provide synchronization in object-oriented languages by locking an object when a method is entered, preventing other threads from entering the same object's methods.

Identify the four deadlock conditions—mutual exclusion, hold and wait, no preemption, and circular wait—and summarize prevention, avoidance, and detection and recovery strategies.

Explore detection and recovery of deadlocks in operating systems using allocation and weighting graphs, where cycles indicate deadlock, and compare recovery options like killing processes or reclaiming resources.

Understand deadlock prevention by examining the four conditions—mutual exclusion, hold and wait, preemption—and using numbered resources with increasing request order to avoid deadlocks.

Explore avoidance in operating systems by denying or granting resource requests to prevent deadlock, using allocation graphs for single resources and the banker's algorithm for multiple ones.