CPU Scheduling and Process Synchronization

SRTN (Shortest Remaining Time Next) is a preemptive CPU scheduling algorithm. When a new process arrives, the scheduler compares the remaining burst time of the current process with the new arrival and selects the one with the shortest remaining time.

FCFS (First-Come, First-Served) is the simplest CPU scheduling algorithm. Processes are scheduled in the order they arrive in the ready queue, following a FIFO (First In, First Out) discipline.

Shortest Remaining Time Next (SRTN) is a preemptive scheduling algorithm. At any scheduling decision point, it selects the process with the shortest remaining execution time from the ready queue. This can minimize average waiting time.

SJF (Shortest Job First) is a CPU scheduling algorithm that selects the process with the smallest next burst time. It can be non-preemptive (once a process starts, it runs to completion) or preemptive (called SRTN).

Time slicing is a scheduling technique where each process is given a fixed time quantum to execute. This is also known as Round Robin scheduling, where processes cycle through execution in equal time slices.

RR stands for Round Robin, a preemptive CPU scheduling algorithm. Each process is assigned a fixed time slice (time quantum) and executes for that duration. If not completed, it moves to the back of the ready queue and cycles through again.

Earliest Deadline First (EDF) is a dynamic priority scheduling algorithm used in real-time systems. The scheduler assigns higher priority to the process with the earliest deadline. The ready process with the closest deadline is selected for execution.

MLQ (Multi-Level Queue) scheduling divides the ready queue into multiple separate queues with different scheduling algorithms. Each queue has its own scheduling policy, and there is typically scheduling among the queues themselves.

Signaling in inter-process communication involves processes sending and receiving signals to exchange timing information and coordinate their actions. Signals are explicit notifications used for synchronization and coordination.

Trace-driven simulation processes recorded event traces from actual system execution, using real-world data as input to study system behavior patterns without affecting the production environment. Self-driven simulation generates synthetic workloads instead.

Inter-process synchronization coordinates access to shared resources among concurrent processes, preventing race conditions and maintaining data integrity and consistency. Communication handles data exchange, while signaling sends notifications.

Self-driven simulation generates synthetic workloads that artificially model expected conditions in the target system, unlike trace-driven simulation which uses recorded real-world event traces. This allows testing scenarios without requiring actual trace data.

Least laxity scheduler is also known as least slack scheduler, because it calculates the laxity (or slack) - the time remaining until deadline minus remaining execution time. It schedules tasks with minimum laxity first, not earliest deadline.

Inter-process communication is the mechanism for exchanging data between processes. Synchronization coordinates timing and access to shared resources, while signaling sends simple notifications. Communication handles the actual data transfer.

SJF (Shortest Job First) is the non-preemptive version of SRTN (Shortest Remaining Time Next). SJF allocates CPU to the process with shortest total burst time and doesn't preempt, while SRTN can preempt when a shorter job arrives.

A critical section is a sequence of instructions that accesses shared resources, with clearly marked beginning and end points. Only one process should execute in its critical section at a time to prevent race conditions.

Mutual exclusion is the principle where a single process temporarily excludes all others from using a shared resource. A critical section is the code segment that implements this, and semaphore is the mechanism used to enforce it.

WAIT operation decrements the semaphore value. If the result is negative, the process is blocked. SIGNAL increments the semaphore. This is the fundamental semaphore operation pair for process synchronization.

SIGNAL operation increments the semaphore value, potentially waking up waiting processes. WAIT decrements it. These are the two primitive semaphore operations used for inter-process synchronization.

WAIT is a primitive semaphore operation (also called P operation). WAIT decrements the semaphore and blocks if needed. SIGNAL (V operation) is the other primitive. BUSY and HALT are not standard semaphore operations.

A binary semaphore can only take values 0 and 1, acting like a mutex lock. It's used for mutual exclusion. General (counting) semaphores can take non-negative integer values and manage multiple resource instances.

General (or counting) semaphores can take any non-negative integer value, unlike binary semaphores which are restricted to 0 and 1. This allows them to track multiple available resources or control access for multiple processes.

Test-and-Set is a fundamental hardware instruction that atomically reads and modifies a memory location, making it ideal for implementing mutual exclusion primitives. Set-and-Test is not a standard hardware instruction.

SIGNAL (also called V or up operation) is one of the two fundamental semaphore operations, along with WAIT (P or down operation). SIGNAL increments the semaphore value, potentially waking a waiting process. BUSY and HALT are not semaphore primitives.

A semaphore is a synchronization primitive that provides mutual exclusion by controlling access to shared resources through a counter. Critical sections are code segments that need mutual exclusion, not the mechanism itself. Mutual exclusion is the concept, not the implementation.