mary / scheduler.nv

|:#############: Scheduler input and config :#############: | || :cycle size: 10 || :: Start from 0 and step by 1000 milliseconds :schedule: Task1 for 1 :schedule: Task2 for 2 :schedule: Task3 for 3 :schedule: ThreeSecondTask for 3 :schedule: Task4 for 4 :schedule: FiveSecondTask for 5 :schedule: EightSecondTask for 8 :schedule: Task9 for 9 :schedule: Task10 for 10 :schedule: Task11 for 11 :schedule: Task15 for 15 :schedule: Task21 for 21 :schedule: Halt for 21 |:#############: Task definitions :#############: | | :run: Halt :clock: $t ? | :@stdio: println Goodbye! :log: Halting from schedule at time $t :: Halt | :run: $task :clock: $t ? | :@stdio: println $task :log: [ Time $t ] running task - $task |:#############: Helpers :#############: | | :let: $variable = :@math: $result | :: $variable = $result |:#############: Debug helpers :#############: | | :clock: $t ? :cycle: $c $i ? :debug: $d | :@stdio: write [dbg] :@stdio: write 32 :@stdio: write [ :@stdio: write clock :@stdio: write 32 :@stdio: print $t :@stdio: write ] :@stdio: write 32 :@stdio: println $d |:#############: Rules :#############: | | :: Start from $start_time and step by $time_step $units | :clock t0: $start_time :clock: 0 :time step: $time_step $units :cycle: 0 0 :: Run process loop | :: Run process loop | :: Check for new tasks :: Run current tasks :: Sleep :: Update clock :: Update future tasks :: Run process loop | :: Sleep :time step: $time_step $unit ? | :: Wake :@time: sleep $time_step $unit :log: Sleeping for $time_step $unit | :: Wake :@time: done | :log: Woken from sleep |:#############: Clock :#############: | | :: Update clock :clock t0: $t0 ? :clock: $t :cycle size: $N ? :cycle: $c $i ? | :let: next_clock = :@math: add $t 1 :let: next_cycle_index = :@math: add $i 1 :log: Updating clock | :: next_clock = $t | :clock: $t | :: next_cycle_index = $i :cycle: $c $_ :cycle size: $N ? | :cycle: $c $i :: check for cycle rollover :@math: compare $i $N :log: Checking for cycle rollover | :: check for cycle rollover :@math: equal | :: reset cycle :log: The cycle rolls over | :: check for cycle rollover :@math: greater | :: reset cycle :log: The cycle rolls over | :: check for cycle rollover :@math: less | :log: No cycle rollover | :: reset cycle :cycle: $c $i ? | :let: next_cycle = :@math: add $c 1 | :: next_cycle = $c :cycle: $_1 $_2 | :cycle: $c 0 :log: Next cycle is $c |:#############: Tasks :#############: | | :: Check for new tasks ? :schedule: $task for $time ? :clock t0: $t0 ? | :log: Calculating cycle for $time :let: time_diff = :@math: subtract $time $t0 | :: time_diff = $result :cycle size: $N ? | :let: time_cycle = :@math: antimodulo $result $N :let: time_index = :@math: modulo $result $N | :schedule: $task for $time ? :: time_index = $index_result :: time_cycle = $cycle_result | :: Time $time will occur at cycle $cycle_result and index $index_result :log: Calculated time $time will occur at cycle $cycle_result and index $index_result | :###: Case A; the new task is in the current cycle | | :: Time $time will occur at cycle $current_cycle and index $i :schedule: $task for $time :cycle: $current_cycle $_ ? | :: Push $task to timestack $i | :###: Case B; the new task is in a future :###: assume that new tasks will not be in the past, so this is a default case | | :: Time $time will occur at cycle $c and index $i :schedule: $task for $time | :future: $time $c $i $task | :: Check for new tasks | |:###: Pulling tasks from the future to the present :###: the future stack is currently unsorted, so this could be optimized | | :: Update future tasks ? :future: $time $c $i $task :cycle: $c 0 ? | :: Push $task to timestack $i | :: Update future tasks ? :future: $time $c $i $task | :next future: $time $c $i $task | :: Update future tasks | :log: No future-era tasks to update | :###: NB this rule has gotta come after the prior rules | | :next future: $time $c $i $task | :future: #time $c $i $task |:#############: pushy push :#############: | | :: Push $task to timestack 0 | :timestack 0: $task | :: Push $task to timestack 1 | :timestack 1: $task | :: Push $task to timestack 2 | :timestack 2: $task | :: Push $task to timestack 3 | :timestack 3: $task | :: Push $task to timestack 4 | :timestack 4: $task | :: Push $task to timestack 5 | :timestack 5: $task | :: Push $task to timestack 6 | :timestack 6: $task | :: Push $task to timestack 7 | :timestack 7: $task | :: Push $task to timestack 8 | :timestack 8: $task | :: Push $task to timestack 9 | :timestack 9: $task |:#############: Task running :#############: | | :: Run current tasks ? :cycle: $_ 0 ? :timestack 0: $task | :run: $task | :: Run current tasks ? :cycle: $_ 1 ? :timestack 1: $task | :run: $task | :: Run current tasks ? :cycle: $_ 2 ? :timestack 2: $task | :run: $task | :: Run current tasks ? :cycle: $_ 3 ? :timestack 3: $task | :run: $task | :: Run current tasks ? :cycle: $_ 4 ? :timestack 4: $task | :run: $task | :: Run current tasks ? :cycle: $_ 5 ? :timestack 5: $task | :run: $task | :: Run current tasks ? :cycle: $_ 6 ? :timestack 6: $task | :run: $task | :: Run current tasks ? :cycle: $_ 7 ? :timestack 7: $task | :run: $task | :: Run current tasks ? :cycle: $_ 8 ? :timestack 8: $task | :run: $task | :: Run current tasks ? :cycle: $_ 9 ? :timestack 9: $task | :run: $task | :: Run current tasks |