Using multi-level feedback queues eliminates process starvation.

Multi-level feedback queues implement a dynamic priority system.

Round Robin is a starvation-free scheduling algorithm.

Using static priorities for scheduling, and ensuring that always a higher priority process is served before any lower priority processes, is always a fair scheduling method and does not entail the danger of process starvation.

In preemptive scheduling, it makes sense to make the quantum time (q) very short (e.g. 1 msec). In this way the CPU will more rapidly swap between processes and the illusion of "many things happening at the same time" will be even stronger.

In non-preemptive scheduling (such as FCFS) it is possible that a process may occupy the CPU until it finishes completing, no matter how long this may take.

Processes whose burst pattern is more like that in the left hand side of the distribution shown in the figure, would correspond mostly to batch processes.

The figure tells us that the majority of processes have relatively short CPU bursts.

Processes whose burst pattern is more like that in the right hand side of the distribution shown in the figure, would correspond mostly to interactive processes.

For batch processes, throughput matters most, while for interactive processes it is response time that matters the most. 

The distribution shown in the graph has no implications for process scheduling.

All processes running on a Linux system are descended from the init (or systemd) process.

A process (e.g. firefox) that is run from a Linux shell becomes a direct child process of the init process.

A process (e.g. firefox) that is run from a shell becomes the parent process of that shell.

It is possible to kill all the processes running on a system when logged in your normal student QMUL account by using the killall command.

Issuing the command “ps” will return a list of all processes running on a system.

Using the top command allows us to see in real time what is going on with processes on our system.

A system call makes the switch to kernel mode via a trap, which is essentially a software interrupt.

A system call is the only way in which a mode switch from user mode to kernel mode can occur.

A system call always causes a context (process) switch.

In our programs we use pcntl_fork  or os.fork() to create a new process. This is the actual system call  and we pass it directly to the kernel for service.

The arguments that users pass to system calls do not need to be examined by the OS - this is the job of the calling programming language.

A process in a suspended state is swapped out of main memory (typically to disk) to free up space in main memory.

In the five state model, a new process is not automatically ready to be dispatched  and may be kept in the New state until it is admitted to the Ready state.

In a system that uses multiple queues, the order in which processes wait for I/O events and the order in which the events occur is guaranteed to be the same.

The transition from "Running " to "Ready/Suspend" seems an odd one but can be explained if we consider process priorities.