Operating Systems

Construct a Gantt chart from process arrival times, CPU bursts, and a stated tie-breaking rule.

Calculate completion, turnaround, waiting, and response times from a CPU schedule.

Calculate CPU utilization and throughput for a workload containing CPU-idle periods and scheduling overhead.

Compare scheduling objectives for batch, interactive, and real-time workloads.

Use exponential averaging to predict a process's next CPU-burst length.

Analyze how workload characteristics affect the suitability of a scheduling policy.

Produce an FCFS schedule and identify when the convoy effect occurs.

Produce a non-preemptive SJF schedule and explain when it minimizes average waiting time.

Produce a preemptive shortest-remaining-time-first schedule for processes with different arrival times.

Produce preemptive and non-preemptive priority schedules using explicit tie-breaking rules.

Demonstrate starvation in priority-based scheduling and correct it using aging.

Produce a Round Robin schedule for a specified time quantum.

Analyze how the Round Robin time quantum changes response time, waiting time, and context-switch overhead.

Select a classical scheduling algorithm for a stated workload and justify the choice using performance metrics.

Construct a multilevel queue schedule with fixed priorities between queues.

Trace process promotion and demotion through a multilevel feedback queue.

Configure MLFQ time quanta and priority-boost rules for a mixed interactive and CPU-bound workload.

Calculate expected CPU shares under lottery scheduling.

Trace deterministic proportional shares using stride scheduling.

Explain how Linux's Completely Fair Scheduler uses weights and virtual runtime to allocate CPU time.

Use Linux priority and niceness concepts to predict the relative CPU shares of competing tasks.

Distinguish process-contention scope from system-contention scope in thread scheduling.

Compare asymmetric and symmetric multiprocessing approaches to scheduling.

Explain how processor affinity can improve cache performance.

Apply push and pull migration concepts to balance work across processors.

Analyze the trade-off between load balancing and cache or NUMA locality.

Assign fixed priorities to periodic tasks using rate-monotonic scheduling.

Test a periodic task set using the rate-monotonic utilization bound.

Construct an earliest-deadline-first schedule for periodic real-time tasks.

Identify priority inversion and show how priority inheritance bounds its impact.

Represent process arrivals, bursts, priorities, and scheduler state with Python data structures.

Implement FCFS and non-preemptive SJF schedulers in Python.

Implement SRTF and preemptive priority schedulers in Python.

Implement a Round Robin scheduler with a ready queue in Python.

Compute per-process and aggregate scheduling metrics from simulator output.

Test scheduler implementations against simultaneous arrivals, idle intervals, ties, and zero-overhead context switches.

Run controlled workload experiments to compare scheduler performance.

Explain and defend a scheduling-policy choice in an operating-systems interview scenario.