Operating system concepts-1

Explore how system calls implement protection boundaries for user programs and compare similar calls across Unix and Windows, including fork, exit, open, read, and write.

Explains how programs pass parameters to system calls across user and kernel spaces, detailing register, memory block, and stack methods; highlights Linux's mixed approach and example system calls.

Understand multiprogramming and multitasking on a single cpu, where ready processes in main memory maximize cpu utilization during io waits through time slices and preemption.

The operating system validates executable and permissions, checks resources to prevent thrashing, allocates memory, loads the program, creates the process control block, and enqueues the process in the ready queue.

A queuing diagram illustrates how processes cycle from the ready queue to the CPU, to IO and waiting queues, with events like IO requests, interrupts, and time-slice expiry.

Explore how cpu scheduling allocates a shared cpu and other resources, and examine cpu bursts and io bursts that drive scheduling decisions across devices.

Distinguish cpu-bound and io-bound processes by bursts; cpu-bound spend most time computing, io-bound wait for io and benefit from optimized response time; examples include scientific simulations and Windows apps.

Analyze how cpu scheduling algorithms affect turnaround time and waiting time using single cpu bursts, arrival times, and termination times in the ready queue.

Examine CPU scheduling algorithms, non preemptive and preemptive types, such as first come first served, shortest remaining time first, and round robin, along with goals like fairness and throughput.

Explore the first come first served scheduling algorithm, examining a ready queue, gantt chart, and a three-process example to compute waiting times and the average waiting time.

Shortest job first is a non-preemptive scheduling method. It assigns cpu to the smallest next cpu burst, breaking ties by arrival order; an example shows arrival times and waiting times.

Prioritize short cpu bursts to minimize average waiting time and favor io-bound interactive processes. Risk starvation for long cpu-bound tasks and cpu hogging due to non-preemptive execution and burst-length unpredictability.

Assigns a priority number to each process and, non-preemptively, allocates the CPU to the highest-priority ready process, breaking ties by first-come, first-served; shortest job first is a special case.

Explains starvation in priority and shortest-job algorithms, and shows aging as a solution by gradually increasing waiting process priority, plus a maximum wait time rule to guarantee CPU access.

SRTF scheduling minimizes average waiting time by always selecting the shortest remaining CPU burst, favoring IO-bound and interactive tasks, but long CPU-burst processes may starve, even with aging.

Explain preemptive priority scheduling where a higher-priority arrival can preempt the current process, illustrated with a four-process example, a Gantt chart, and derived waiting, turnaround, and termination times.

Modern operating systems combine scheduling algorithms by partitioning the ready queue into foreground and background queues. A meta level scheduler selects next queue, using fixed priority, aging, or time slicing.

Fork creates a new child with its own pid and pcb in the ready queue, scheduled by the cpu scheduler, and runs concurrently with the parent unless wait suspends it.

Explore the fork system call, which returns a pid_t representing the new process id; see how the parent and child become copies, continue after fork, and run concurrently under scheduling.

Fork creates a child with a separate memory space that copies the parent’s data; the child gets 0 and the parent gets the child’s pid, with exec replacing the child.

Explore how Linux creates and manages parent and child processes through fork, exec, and wait, how resources are inherited via file descriptors, and how interprocess communication enables collaboration.

Explore a simple fork example that contrasts child and parent processes running concurrently, using a switch-case to print I am the child or I am the parent with child pid.

Interprocess communication (IPC) explains independent and cooperating processes and why cooperation enables information sharing, faster computation, and modular design. It introduces shared memory and message parsing models.

Explore message passing for IPC, where two cooperating processes on separate machines communicate via send and receive system calls, contrasting networked IPC with shared memory.