Real-time scheduling and priority inversion

Python 3.14 · main.py

def simulate(tasks: list[tuple[int, int]], horizon: int, rule: str) -> tuple[str, str]:
    """One CPU in 1 ms steps: the timeline and the first missed deadline."""
    left = [0] * len(tasks)  # work left in each current job
    deadline = [0] * len(tasks)

    def key(i: int) -> tuple[int, int]:
        # RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
        return (tasks[i][1] if rule == "RM" else deadline[i], i)

    timeline = ""
    for t in range(horizon + 1):
        for i, (work, period) in enumerate(tasks):
            if t % period == 0:
                if left[i]:
                    return (
                        timeline,
                        f"T{i + 1} misses its deadline at {t} ms, {left[i]} ms short",
                    )
                left[i], deadline[i] = work, t + period
        if t == horizon:
            break
        pick = min((i for i in range(len(tasks)) if left[i]), key=key, default=-1)
        if pick >= 0:
            left[pick] -= 1
        timeline += str(pick + 1) if pick >= 0 else "."
    return timeline, f"no deadline missed in {horizon} ms"


tasks, horizon = [(2, 5), (4, 7)], 35  # (work, period) in ms, and the hyperperiod
print("tasks (work/period):", " ".join(f"{w}/{p}" for w, p in tasks))
for rule in ["RM", "EDF"]:
    timeline, verdict = simulate(tasks, horizon, rule)
    print(f"  {rule:<3} {timeline}\n      {verdict}")

In Python: min over the tasks with work left, keyed on (period or deadline, index), gives a tie to T1, and default=-1 marks a millisecond with nothing to run.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

// One CPU in 1 ms steps: the timeline and the first missed deadline.
function simulate(tasks, horizon, rule) {
  const left = tasks.map(() => 0); // work left in each current job
  const deadline = tasks.map(() => 0);
  let timeline = "";
  for (let t = 0; t <= horizon; t++) {
    for (const [i, [work, period]] of tasks.entries()) {
      if (t % period !== 0) continue;
      if (left[i] > 0)
        return [timeline, `T${i + 1} misses its deadline at ${t} ms, ${left[i]} ms short`];
      [left[i], deadline[i]] = [work, t + period];
    }
    if (t === horizon) break;
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    const key = (i) => (rule === "RM" ? tasks[i][1] : deadline[i]);
    let pick = -1;
    for (let i = 0; i < tasks.length; i++) {
      if (left[i] > 0 && (pick < 0 || key(i) < key(pick))) pick = i;
    }
    if (pick >= 0) left[pick]--;
    timeline += pick >= 0 ? String(pick + 1) : ".";
  }
  return [timeline, `no deadline missed in ${horizon} ms`];
}

const tasks = [
  [2, 5],
  [4, 7],
]; // (work, period) in ms
const horizon = 35; // the hyperperiod, when both periods end together
console.log(`tasks (work/period): ${tasks.map(([work, period]) => `${work}/${period}`).join(" ")}`);
for (const rule of ["RM", "EDF"]) {
  const [timeline, verdict] = simulate(tasks, horizon, rule);
  console.log(`  ${rule.padEnd(3)} ${timeline}\n      ${verdict}`);
}

In JavaScript: The loop keeps a task only when its key is strictly smaller than the best so far, so a tie goes to T1; a destructuring assignment releases a job in one statement.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.ArrayList;
import java.util.List;
import java.util.function.IntUnaryOperator;

public class Main {
  record Task(int work, int period) {} // in ms

  // One CPU in 1 ms steps: the timeline and the first missed deadline.
  static String[] simulate(List<Task> tasks, int horizon, String rule) {
    int[] left = new int[tasks.size()]; // work left in each current job
    int[] deadline = new int[tasks.size()];
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    IntUnaryOperator key = i -> rule.equals("RM") ? tasks.get(i).period() : deadline[i];
    StringBuilder timeline = new StringBuilder();
    for (int t = 0; t <= horizon; t++) {
      for (int i = 0; i < tasks.size(); i++) {
        if (t % tasks.get(i).period() != 0) {
          continue;
        }
        if (left[i] > 0) {
          String miss = "T" + (i + 1) + " misses its deadline at " + t + " ms, " + left[i];
          return new String[] {timeline.toString(), miss + " ms short"};
        }
        left[i] = tasks.get(i).work();
        deadline[i] = t + tasks.get(i).period();
      }
      if (t == horizon) {
        break;
      }
      int pick = -1;
      for (int i = 0; i < tasks.size(); i++) {
        if (left[i] > 0 && (pick < 0 || key.applyAsInt(i) < key.applyAsInt(pick))) {
          pick = i;
        }
      }
      if (pick >= 0) {
        left[pick]--;
      }
      timeline.append(pick >= 0 ? String.valueOf(pick + 1) : ".");
    }
    return new String[] {timeline.toString(), "no deadline missed in " + horizon + " ms"};
  }

  public static void main(String[] args) {
    List<Task> tasks = List.of(new Task(2, 5), new Task(4, 7));
    int horizon = 35; // the hyperperiod, when both periods end together
    List<String> shown = new ArrayList<>();
    tasks.forEach(t -> shown.add(t.work() + "/" + t.period()));
    System.out.println("tasks (work/period): " + String.join(" ", shown));
    for (String rule : List.of("RM", "EDF")) {
      String[] run = simulate(tasks, horizon, rule);
      System.out.println("  " + rule + (rule.length() < 3 ? " " : "") + " " + run[0]);
      System.out.println("      " + run[1]);
    }
  }
}

In Java: A record holds each task and an IntUnaryOperator the key of the rule; simulate returns the timeline and the verdict in a two-element array.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <format>
#include <print>
#include <string>
#include <utility>
#include <vector>

struct Task {
  int work, period; // in ms
};

// One CPU in 1 ms steps: the timeline and the first missed deadline.
std::pair<std::string, std::string>
simulate(const std::vector<Task> &tasks, int horizon, const std::string &rule) {
  std::vector<int> left(tasks.size()); // work left in each current job
  std::vector<int> deadline(tasks.size());
  // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
  auto key = [&](std::size_t i) {
    return rule == "RM" ? tasks[i].period : deadline[i];
  };
  std::string timeline;
  for (int t = 0; t <= horizon; ++t) {
    for (std::size_t i = 0; i < tasks.size(); ++i) {
      if (t % tasks[i].period != 0) {
        continue;
      }
      if (left[i] > 0) {
        return {timeline,
                std::format("T{} misses its deadline at {} ms, {} ms short",
                            i + 1, t, left[i])};
      }
      left[i] = tasks[i].work;
      deadline[i] = t + tasks[i].period;
    }
    if (t == horizon) {
      break;
    }
    std::size_t pick = tasks.size();
    for (std::size_t i = 0; i < tasks.size(); ++i) {
      if (left[i] > 0 && (pick == tasks.size() || key(i) < key(pick))) {
        pick = i;
      }
    }
    if (pick < tasks.size()) {
      --left[pick];
    }
    timeline += pick < tasks.size() ? std::to_string(pick + 1) : ".";
  }
  return {timeline, std::format("no deadline missed in {} ms", horizon)};
}

int main() {
  const std::vector<Task> tasks = {{2, 5}, {4, 7}};
  const int horizon = 35; // the hyperperiod, when both periods end together
  std::string shown;
  for (const Task &task : tasks) {
    shown += std::format(" {}/{}", task.work, task.period);
  }
  std::println("tasks (work/period):{}", shown);
  for (const std::string rule : {"RM", "EDF"}) {
    const auto [timeline, verdict] = simulate(tasks, horizon, rule);
    std::println("  {:<3} {}\n      {}", rule, timeline, verdict);
  }
}

In C++: simulate returns a std::pair that main takes apart with a structured binding, and std::format builds the verdict that std::println prints.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

Task[] tasks = [new(2, 5), new(4, 7)];
int horizon = 35; // the hyperperiod, when both periods end together
var shown = tasks.Select(t => $"{t.Work}/{t.Period}");
Console.WriteLine($"tasks (work/period): {string.Join(" ", shown)}");
foreach (string rule in new[] { "RM", "EDF" })
{
    var (timeline, verdict) = Simulate(tasks, horizon, rule);
    Console.WriteLine($"  {rule,-3} {timeline}\n      {verdict}");
}

// One CPU in 1 ms steps: the timeline and the first missed deadline.
static (string, string) Simulate(Task[] tasks, int horizon, string rule)
{
    int[] left = new int[tasks.Length]; // work left in each current job
    int[] deadline = new int[tasks.Length];
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    int Key(int i) => rule == "RM" ? tasks[i].Period : deadline[i];
    string timeline = "";
    for (int t = 0; t <= horizon; t++)
    {
        for (int i = 0; i < tasks.Length; i++)
        {
            if (t % tasks[i].Period != 0)
            {
                continue;
            }
            if (left[i] > 0)
            {
                return (timeline, $"T{i + 1} misses its deadline at {t} ms, {left[i]} ms short");
            }
            (left[i], deadline[i]) = (tasks[i].Work, t + tasks[i].Period);
        }
        if (t == horizon)
        {
            break;
        }
        int pick = -1;
        for (int i = 0; i < tasks.Length; i++)
        {
            if (left[i] > 0 && (pick < 0 || Key(i) < Key(pick)))
            {
                pick = i;
            }
        }
        if (pick >= 0)
        {
            left[pick]--;
        }
        timeline += pick >= 0 ? $"{pick + 1}" : ".";
    }
    return (timeline, $"no deadline missed in {horizon} ms");
}

record Task(int Work, int Period); // in ms

In C#: The top-level statements come first and the local function Simulate after them; a tuple assignment releases a job in one statement.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>

enum { MAX_TASKS = 8 };

struct task {
  int work, period; // in ms
};

// One CPU in 1 ms steps: prints the timeline and the first missed deadline.
static void simulate(const struct task tasks[], int n, int horizon, bool rm) {
  int left[MAX_TASKS] = {0}; // work left in each current job
  int deadline[MAX_TASKS] = {0};
  printf("  %-3s ", rm ? "RM" : "EDF");
  for (int t = 0; t <= horizon; t++) {
    for (int i = 0; i < n; i++) {
      if (t % tasks[i].period != 0) {
        continue;
      }
      if (left[i] > 0) {
        printf("\n      T%d misses its deadline at %d ms, %d ms short\n", i + 1,
               t, left[i]);
        return;
      }
      left[i] = tasks[i].work;
      deadline[i] = t + tasks[i].period;
    }
    if (t == horizon) {
      break;
    }
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    int pick = -1;
    for (int i = 0; i < n; i++) {
      const int key = rm ? tasks[i].period : deadline[i];
      if (left[i] > 0 &&
          (pick < 0 || key < (rm ? tasks[pick].period : deadline[pick]))) {
        pick = i;
      }
    }
    if (pick >= 0) {
      left[pick]--;
    }
    putchar(pick >= 0 ? '1' + pick : '.');
  }
  printf("\n      no deadline missed in %d ms\n", horizon);
}

int main(void) {
  static const struct task tasks[] = {{2, 5}, {4, 7}};
  const int n = (int)(sizeof tasks / sizeof tasks[0]);
  const int horizon = 35; // the hyperperiod, when both periods end together
  printf("tasks (work/period):");
  for (int i = 0; i < n; i++) {
    printf(" %d/%d", tasks[i].work, tasks[i].period);
  }
  printf("\n");
  simulate(tasks, n, horizon, true);
  simulate(tasks, n, horizon, false);
  return 0;
}

In C: simulate prints the timeline as it goes instead of building a string, so a missed deadline ends the line early; putchar prints the task number as a character.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

/**
 * One CPU in 1 ms steps: the timeline and the first missed deadline.
 * @param list<array{int, int}> $tasks [work, period] in ms
 * @return array{string, string}
 */
function simulate(array $tasks, int $horizon, string $rule): array
{
    $left = array_fill(0, count($tasks), 0); // work left in each current job
    $deadline = $left;
    $timeline = '';
    for ($t = 0; $t <= $horizon; $t++) {
        foreach ($tasks as $i => [$work, $period]) {
            if ($t % $period !== 0) {
                continue;
            }
            if ($left[$i] > 0) {
                $miss = 'T' . ($i + 1) . " misses its deadline at {$t} ms, {$left[$i]} ms short";
                return [$timeline, $miss];
            }
            [$left[$i], $deadline[$i]] = [$work, $t + $period];
        }
        if ($t === $horizon) {
            break;
        }
        // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
        $key = fn(int $i): int => $rule === 'RM' ? $tasks[$i][1] : $deadline[$i];
        $pick = -1;
        foreach (array_keys($tasks) as $i) {
            if ($left[$i] > 0 && ($pick < 0 || $key($i) < $key($pick))) {
                $pick = $i;
            }
        }
        if ($pick >= 0) {
            $left[$pick]--;
        }
        $timeline .= $pick >= 0 ? (string) ($pick + 1) : '.';
    }
    return [$timeline, "no deadline missed in {$horizon} ms"];
}

$tasks = [[2, 5], [4, 7]];
$horizon = 35; // the hyperperiod, when both periods end together
$shown = array_map(fn(array $task): string => "{$task[0]}/{$task[1]}", $tasks);
echo 'tasks (work/period): ' . implode(' ', $shown) . "\n";
foreach (['RM', 'EDF'] as $rule) {
    [$timeline, $verdict] = simulate($tasks, $horizon, $rule);
    printf("  %-3s %s\n      %s\n", $rule, $timeline, $verdict);
}

In PHP: An arrow function (fn) copies the variables it uses when it is created, so $key is created again every millisecond to see the current deadlines.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

// One CPU in 1 ms steps: the timeline and the first missed deadline.
fn simulate(tasks: &[(u32, u32)], horizon: u32, rule: &str) -> (String, String) {
    let mut left = vec![0; tasks.len()]; // work left in each current job
    let mut deadline = vec![0; tasks.len()];
    let mut timeline = String::new();
    for t in 0..=horizon {
        for (i, &(work, period)) in tasks.iter().enumerate() {
            if t % period != 0 {
                continue;
            }
            if left[i] > 0 {
                let miss = format!(
                    "T{} misses its deadline at {t} ms, {} ms short",
                    i + 1,
                    left[i]
                );
                return (timeline, miss);
            }
            (left[i], deadline[i]) = (work, t + period);
        }
        if t == horizon {
            break;
        }
        // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
        let key = |i: usize| {
            if rule == "RM" {
                tasks[i].1
            } else {
                deadline[i]
            }
        };
        match (0..tasks.len())
            .filter(|&i| left[i] > 0)
            .min_by_key(|&i| (key(i), i))
        {
            Some(pick) => {
                left[pick] -= 1;
                timeline += &(pick + 1).to_string();
            }
            None => timeline.push('.'),
        }
    }
    (timeline, format!("no deadline missed in {horizon} ms"))
}

fn main() {
    let tasks = [(2, 5), (4, 7)]; // (work, period) in ms
    let horizon = 35; // the hyperperiod, when both periods end together
    let shown: Vec<String> = tasks.iter().map(|(w, p)| format!("{w}/{p}")).collect();
    println!("tasks (work/period): {}", shown.join(" "));
    for rule in ["RM", "EDF"] {
        let (timeline, verdict) = simulate(&tasks, horizon, rule);
        println!("  {rule:<3} {timeline}\n      {verdict}");
    }
}

In Rust: min_by_key on (key, index) returns the first minimum, which gives a tie to T1, and the match handles the idle millisecond as None.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

type Task = [work: number, period: number]; // in ms

// One CPU in 1 ms steps: the timeline and the first missed deadline.
function simulate(tasks: Task[], horizon: number, rule: string): [string, string] {
  const left = tasks.map(() => 0); // work left in each current job
  const deadline = tasks.map(() => 0);
  let timeline = "";
  for (let t = 0; t <= horizon; t++) {
    for (const [i, [work, period]] of tasks.entries()) {
      if (t % period !== 0) continue;
      if (left[i] > 0)
        return [timeline, `T${i + 1} misses its deadline at ${t} ms, ${left[i]} ms short`];
      [left[i], deadline[i]] = [work, t + period];
    }
    if (t === horizon) break;
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    const key = (i: number): number => (rule === "RM" ? tasks[i][1] : deadline[i]);
    let pick = -1;
    for (let i = 0; i < tasks.length; i++) {
      if (left[i] > 0 && (pick < 0 || key(i) < key(pick))) pick = i;
    }
    if (pick >= 0) left[pick]--;
    timeline += pick >= 0 ? String(pick + 1) : ".";
  }
  return [timeline, `no deadline missed in ${horizon} ms`];
}

const tasks: Task[] = [
  [2, 5],
  [4, 7],
];
const horizon = 35; // the hyperperiod, when both periods end together
console.log(`tasks (work/period): ${tasks.map(([work, period]) => `${work}/${period}`).join(" ")}`);
for (const rule of ["RM", "EDF"]) {
  const [timeline, verdict] = simulate(tasks, horizon, rule);
  console.log(`  ${rule.padEnd(3)} ${timeline}\n      ${verdict}`);
}

In TypeScript: A labelled tuple type, [work: number, period: number], names the two numbers of each task, and simulate returns a pair of strings.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strconv"
)

type task struct{ work, period int } // in ms

// simulate runs one CPU in 1 ms steps and returns the timeline and the first missed deadline.
func simulate(tasks []task, horizon int, rule string) (string, string) {
	left := make([]int, len(tasks)) // work left in each current job
	deadline := make([]int, len(tasks))
	// RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
	key := func(i int) int {
		if rule == "RM" {
			return tasks[i].period
		}
		return deadline[i]
	}
	timeline := ""
	for t := 0; t <= horizon; t++ {
		for i, tk := range tasks {
			if t%tk.period != 0 {
				continue
			}
			if left[i] > 0 {
				miss := fmt.Sprintf("T%d misses its deadline at %d ms, %d ms short",
					i+1, t, left[i])
				return timeline, miss
			}
			left[i], deadline[i] = tk.work, t+tk.period
		}
		if t == horizon {
			break
		}
		pick := -1
		for i := range tasks {
			if left[i] > 0 && (pick < 0 || key(i) < key(pick)) {
				pick = i
			}
		}
		if pick < 0 {
			timeline += "."
			continue
		}
		left[pick]--
		timeline += strconv.Itoa(pick + 1)
	}
	return timeline, fmt.Sprintf("no deadline missed in %d ms", horizon)
}

func main() {
	tasks := []task{{2, 5}, {4, 7}}
	horizon := 35 // the hyperperiod, when both periods end together
	fmt.Print("tasks (work/period):")
	for _, tk := range tasks {
		fmt.Printf(" %d/%d", tk.work, tk.period)
	}
	fmt.Println()
	for _, rule := range []string{"RM", "EDF"} {
		timeline, verdict := simulate(tasks, horizon, rule)
		fmt.Printf("  %-3s %s\n      %s\n", rule, timeline, verdict)
	}
}

In Go: key is a closure over rule and deadline, and simulate returns two strings, the Go way to return a pair.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

/// One CPU in 1 ms steps: the timeline and the first missed deadline.
func simulate(_ tasks: [(work: Int, period: Int)], _ horizon: Int, _ rule: String) -> (
  String, String
) {
  var left = [Int](repeating: 0, count: tasks.count)  // work left in each current job
  var deadline = left
  // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
  let key = { (i: Int) in rule == "RM" ? tasks[i].period : deadline[i] }
  var timeline = ""
  for t in 0...horizon {
    for (i, task) in tasks.enumerated() where t % task.period == 0 {
      if left[i] > 0 {
        return (timeline, "T\(i + 1) misses its deadline at \(t) ms, \(left[i]) ms short")
      }
      (left[i], deadline[i]) = (task.work, t + task.period)
    }
    if t == horizon { break }
    guard let pick = tasks.indices.filter({ left[$0] > 0 }).min(by: { key($0) < key($1) }) else {
      timeline += "."
      continue
    }
    left[pick] -= 1
    timeline += String(pick + 1)
  }
  return (timeline, "no deadline missed in \(horizon) ms")
}

let tasks = [(work: 2, period: 5), (work: 4, period: 7)]
let horizon = 35  // the hyperperiod, when both periods end together
print("tasks (work/period): \(tasks.map { "\($0.work)/\($0.period)" }.joined(separator: " "))")
for rule in ["RM", "EDF"] {
  let (timeline, verdict) = simulate(tasks, horizon, rule)
  print("  \(rule)\(rule.count < 3 ? " " : "") \(timeline)\n      \(verdict)")
}

In Swift: The where clause of the inner loop releases jobs only at multiples of the period, and guard let handles the idle millisecond.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# One CPU in 1 ms steps: the timeline and the first missed deadline.
class Simulation
  def initialize(tasks, rule)
    @tasks = tasks # [work, period] in ms
    @rule = rule
    @left = [0] * tasks.size # work left in each current job
    @deadline = [0] * tasks.size
  end

  def call(horizon)
    timeline = +''
    (0..horizon).each do |t|
      missed = release(t)
      return [timeline, missed] if missed
      break if t == horizon

      timeline << step
    end
    [timeline, "no deadline missed in #{horizon} ms"]
  end

  private

  def release(time)
    @tasks.each_with_index do |(work, period), i|
      next unless (time % period).zero?

      miss = "T#{i + 1} misses its deadline at #{time} ms, #{@left[i]} ms short"
      return miss if @left[i].positive?

      @left[i] = work
      @deadline[i] = time + period
    end
    nil
  end

  # RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
  def step
    pick = @tasks.each_index.select { |i| @left[i].positive? }.min_by { |i| [key(i), i] }
    return '.' unless pick

    @left[pick] -= 1
    (pick + 1).to_s
  end

  def key(index) = @rule == 'RM' ? @tasks[index][1] : @deadline[index]
end

tasks = [[2, 5], [4, 7]] # [work, period] in ms
horizon = 35 # the hyperperiod, when both periods end together
puts "tasks (work/period): #{tasks.map { |work, period| "#{work}/#{period}" }.join(' ')}"
%w[RM EDF].each do |rule|
  timeline, verdict = Simulation.new(tasks, rule).call(horizon)
  puts "  #{rule.ljust(3)} #{timeline}", "      #{verdict}"
end

In Ruby: A small class with one method per step keeps each method short, as RuboCop asks, and min_by with [key, index] gives a tie to T1.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

data class Task(
    val work: Int,
    val period: Int,
) // in ms

// One CPU in 1 ms steps: the timeline and the first missed deadline.
fun simulate(
    tasks: List<Task>,
    horizon: Int,
    rule: String,
): Pair<String, String> {
    val left = IntArray(tasks.size) // work left in each current job
    val deadline = IntArray(tasks.size)
    // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
    val key = { i: Int -> if (rule == "RM") tasks[i].period else deadline[i] }
    val timeline = StringBuilder()
    for (t in 0..horizon) {
        for ((i, task) in tasks.withIndex()) {
            if (t % task.period != 0) continue
            val miss = "T${i + 1} misses its deadline at $t ms, ${left[i]} ms short"
            if (left[i] > 0) return "$timeline" to miss
            left[i] = task.work
            deadline[i] = t + task.period
        }
        if (t == horizon) break
        val pick = tasks.indices.filter { left[it] > 0 }.minByOrNull(key)
        if (pick != null) left[pick]--
        timeline.append(if (pick != null) "${pick + 1}" else ".")
    }
    return "$timeline" to "no deadline missed in $horizon ms"
}

fun main() {
    val tasks = listOf(Task(2, 5), Task(4, 7))
    val horizon = 35 // the hyperperiod, when both periods end together
    println("tasks (work/period): ${tasks.joinToString(" ") { "${it.work}/${it.period}" }}")
    for (rule in listOf("RM", "EDF")) {
        val (timeline, verdict) = simulate(tasks, horizon, rule)
        println("  ${rule.padEnd(3)} $timeline\n      $verdict")
    }
}

In Kotlin: minByOrNull returns the first task with the smallest key, so a tie goes to T1, and null marks an idle millisecond.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

typedef Task = ({int work, int period}); // in ms

/// One CPU in 1 ms steps: the timeline and the first missed deadline.
(String, String) simulate(List<Task> tasks, int horizon, String rule) {
  final left = List.filled(tasks.length, 0); // work left in each current job
  final deadline = List.filled(tasks.length, 0);
  // RM: the shorter period first; EDF: the earlier deadline. Ties: T1 first.
  int key(int i) => rule == 'RM' ? tasks[i].period : deadline[i];
  var timeline = '';
  for (var t = 0; t <= horizon; t++) {
    for (final (i, task) in tasks.indexed) {
      if (t % task.period != 0) continue;
      if (left[i] > 0) {
        return (
          timeline,
          'T${i + 1} misses its deadline at $t ms, ${left[i]} ms short',
        );
      }
      left[i] = task.work;
      deadline[i] = t + task.period;
    }
    if (t == horizon) break;
    var pick = -1;
    for (var i = 0; i < tasks.length; i++) {
      if (left[i] > 0 && (pick < 0 || key(i) < key(pick))) pick = i;
    }
    if (pick >= 0) left[pick]--;
    timeline += pick >= 0 ? '${pick + 1}' : '.';
  }
  return (timeline, 'no deadline missed in $horizon ms');
}

void main() {
  final List<Task> tasks = [(work: 2, period: 5), (work: 4, period: 7)];
  const horizon = 35; // the hyperperiod, when both periods end together
  print(
    'tasks (work/period): ${tasks.map((t) => '${t.work}/${t.period}').join(' ')}',
  );
  for (final rule in ['RM', 'EDF']) {
    final (timeline, verdict) = simulate(tasks, horizon, rule);
    print('  ${rule.padRight(3)} $timeline\n      $verdict');
  }
}

In Dart: A record typedef names the work and period of each task, and simulate returns a record of two strings that main takes apart with a pattern.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart