Time-Slice Scheduler

Compute when each job finishes on a shared processor that serves jobs in round-robin time slices.

jobs[i] = [arrival, duration] is a job that appears at time arrival and needs duration ticks of processor time in total. The processor serves one job at a time, in slices of at most quantum ticks, using a first-in-first-out ready queue:

• When the processor is idle and the queue is empty, time jumps to the next arrival. Jobs with the same arrival time enter the queue in input order (lower index first).
• The job at the front of the queue leaves the queue and runs for min(quantum, its remaining time) ticks without interruption.
• When a slice ends at time t, first every job that has arrived by then (arrival <= t) is added to the back of the queue, in order of arrival time and then input index. Then, if the job that just ran still has time left, it goes to the back of the queue after them. So a job that arrives at exactly time t goes in front of the job that was just preempted.
• A job whose remaining time reaches 0 at the end of a slice finishes at that time, even if that slice was a full quantum. It is not queued again.
• The processor is idle only when the queue is empty and the next job has not arrived yet. Nothing else takes time (switching jobs is free).

Durations are large (up to 10^15), so simulating every slice one by one is too slow.

Input: jobs, a list of [arrival, duration] pairs, and quantum, an integer.

Output: a list with the finish time of each job, in the same order as jobs. If there are no jobs, return [].