merge: Increase minimum Java version to 17 (#115)

This pull request increases the minimum version of Java required by OpenDC to 17.
This new version of Java introduces several new features compared to our old minimum 
version (11), which we attempt to apply in this conversion.

## Implementation Notes :hammer_and_pick:

* Increase minimum Java version to Java 17 
* Use RandomGenerator as randomness source 
* Add common dispatcher interface 
* Add compatibility with Kotlin coroutines
* Use InstantSource as time source
* Re-implement SimulationScheduler as Dispatcher 
* Replace use of CoroutineContext by Dispatcher 

## External Dependencies :four_leaf_clover:

* Java 17

## Breaking API Changes :warning:

* The use of `CoroutineContext` and `Clock` as parameters of classes has been replaced 
  by the `Dispatcher` interface.
* The use of `Clock` has been replaced by `InstantSource` which does not carry time
   zone info.
* The use of `Random` and `SplittableRandom` as parameter type has been replaced 
   by `RandomGenerator`

4 files changed, 17 insertions, 38 deletions

diff --git a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
index eb308970..53bf5aa6 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/core/SimTFDevice.kt
@@ -22,12 +22,9 @@
 
 package org.opendc.experiments.tf20.core
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
+import org.opendc.common.Dispatcher
 import org.opendc.simulator.compute.SimBareMetalMachine
 import org.opendc.simulator.compute.SimMachine
 import org.opendc.simulator.compute.SimMachineContext
@@ -36,17 +33,14 @@ import org.opendc.simulator.compute.model.MachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingUnit
 import org.opendc.simulator.compute.power.CpuPowerModel
-import org.opendc.simulator.compute.runWorkload
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.flow2.FlowEngine
 import org.opendc.simulator.flow2.FlowStage
 import org.opendc.simulator.flow2.FlowStageLogic
 import org.opendc.simulator.flow2.OutPort
-import java.time.Clock
 import java.util.ArrayDeque
 import java.util.UUID
 import kotlin.coroutines.Continuation
-import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
 import kotlin.math.ceil
 import kotlin.math.roundToLong
@@ -57,22 +51,16 @@ import kotlin.math.roundToLong
 public class SimTFDevice(
     override val uid: UUID,
     override val isGpu: Boolean,
-    context: CoroutineContext,
-    clock: Clock,
+    dispatcher: Dispatcher,
     pu: ProcessingUnit,
     private val memory: MemoryUnit,
     powerModel: CpuPowerModel
 ) : TFDevice {
     /**
-     * The scope in which the device runs.
-     */
-    private val scope = CoroutineScope(context + Job())
-
-    /**
      * The [SimMachine] representing the device.
      */
     private val machine = SimBareMetalMachine.create(
-        FlowEngine.create(context, clock).newGraph(),
+        FlowEngine.create(dispatcher).newGraph(),
         MachineModel(listOf(pu), listOf(memory)),
         SimPsuFactories.simple(powerModel)
     )
@@ -162,9 +150,7 @@ public class SimTFDevice(
     }
 
     init {
-        scope.launch {
-            machine.runWorkload(workload)
-        }
+        machine.startWorkload(workload, emptyMap()) {}
     }
 
     override suspend fun load(dataSize: Long) {
@@ -185,7 +171,6 @@ public class SimTFDevice(
 
     override fun close() {
         machine.cancel()
-        scope.cancel()
     }
 
     private data class Work(var flops: Double, val cont: Continuation<Unit>) {
diff --git a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
index 7d65a674..5b408fb3 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/main/kotlin/org/opendc/experiments/tf20/network/NetworkController.kt
@@ -23,19 +23,18 @@
 package org.opendc.experiments.tf20.network
 
 import kotlinx.coroutines.channels.Channel
+import org.opendc.common.Dispatcher
 import org.opendc.common.util.TimerScheduler
-import java.time.Clock
-import kotlin.coroutines.CoroutineContext
 
 /**
  * The network controller represents a simple network model between the worker and master nodes during
  * TensorFlow execution.
  */
-public class NetworkController(context: CoroutineContext, clock: Clock) : AutoCloseable {
+public class NetworkController(dispatcher: Dispatcher) : AutoCloseable {
     /**
      * The scheduler for the message.
      */
-    private val scheduler = TimerScheduler<Message>(context, clock)
+    private val scheduler = TimerScheduler<Message>(dispatcher)
 
     /**
      * The outbound communication channels.
diff --git a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
index 32f72686..899aafc0 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/TensorFlowTest.kt
@@ -48,8 +48,7 @@ class TensorFlowTest {
         val device = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            clock,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -67,7 +66,7 @@ class TensorFlowTest {
 
         val stats = device.getDeviceStats()
         assertAll(
-            { assertEquals(3309694252, clock.millis()) },
+            { assertEquals(3309694252, timeSource.millis()) },
             { assertEquals(8.27423563E8, stats.energyUsage) }
         )
     }
@@ -83,8 +82,7 @@ class TensorFlowTest {
         val device = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            clock,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -102,7 +100,7 @@ class TensorFlowTest {
 
         val stats = device.getDeviceStats()
         assertAll(
-            { assertEquals(176230328513, clock.millis()) },
+            { assertEquals(176230328513, timeSource.millis()) },
             { assertEquals(4.405758212825E10, stats.energyUsage) }
         )
     }
@@ -118,8 +116,7 @@ class TensorFlowTest {
         val deviceA = SimTFDevice(
             def.uid,
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            clock,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -128,8 +125,7 @@ class TensorFlowTest {
         val deviceB = SimTFDevice(
             UUID.randomUUID(),
             def.meta["gpu"] as Boolean,
-            coroutineContext,
-            clock,
+            dispatcher,
             def.model.cpus[0],
             def.model.memory[0],
             CpuPowerModels.linear(250.0, 60.0)
@@ -150,7 +146,7 @@ class TensorFlowTest {
         val statsA = deviceA.getDeviceStats()
         val statsB = deviceB.getDeviceStats()
         assertAll(
-            { assertEquals(1704994000, clock.millis()) },
+            { assertEquals(1704994000, timeSource.millis()) },
             { assertEquals(4.262485E8, statsA.energyUsage) },
             { assertEquals(4.262485E8, statsB.energyUsage) }
         )
diff --git a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
index 910cbcc9..549c6f3e 100644
--- a/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
+++ b/opendc-experiments/opendc-experiments-tf20/src/test/kotlin/org/opendc/experiments/tf20/core/SimTFDeviceTest.kt
@@ -47,8 +47,7 @@ internal class SimTFDeviceTest {
         val device = SimTFDevice(
             UUID.randomUUID(),
             isGpu = true,
-            coroutineContext,
-            clock,
+            dispatcher,
             pu,
             memory,
             CpuPowerModels.linear(250.0, 100.0)
@@ -56,7 +55,7 @@ internal class SimTFDeviceTest {
 
         // Load 1 GiB into GPU memory
         device.load(1000)
-        assertEquals(1140, clock.millis())
+        assertEquals(1140, timeSource.millis())
 
         coroutineScope {
             launch { device.compute(1e6) }
@@ -68,7 +67,7 @@ internal class SimTFDeviceTest {
         val stats = device.getDeviceStats()
 
         assertAll(
-            { assertEquals(3681, clock.millis()) },
+            { assertEquals(3681, timeSource.millis()) },
             { assertEquals(749.25, stats.energyUsage) }
         )
     }