From 0711d4c1d6afb41ca31afbf8bd6253921d57eeb4 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Fri, 18 Feb 2022 14:45:05 +0100
Subject: perf(common): Optimize TimerScheduler

This change updates the TimerScheduler implementation to directly use
the Delay object instead of running the timers inside a coroutine.
Constructing the coroutine is more expensive, so we prefer running in a
Runnable.
---
 .../org/opendc/common/util/TimerSchedulerTest.kt   | 46 ++++++++++------------
 1 file changed, 20 insertions(+), 26 deletions(-)

(limited to 'opendc-common/src/test')

diff --git a/opendc-common/src/test/kotlin/org/opendc/common/util/TimerSchedulerTest.kt b/opendc-common/src/test/kotlin/org/opendc/common/util/TimerSchedulerTest.kt
index 89b0cbe9..01f61f92 100644
--- a/opendc-common/src/test/kotlin/org/opendc/common/util/TimerSchedulerTest.kt
+++ b/opendc-common/src/test/kotlin/org/opendc/common/util/TimerSchedulerTest.kt
@@ -27,21 +27,30 @@ import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
+import java.time.Clock
+import kotlin.coroutines.EmptyCoroutineContext
 
 /**
  * A test suite for the [TimerScheduler] class.
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class TimerSchedulerTest {
+    @Test
+    fun testEmptyContext() {
+        assertThrows<IllegalArgumentException> { TimerScheduler<Unit>(EmptyCoroutineContext, Clock.systemUTC()) }
+    }
+
     @Test
     fun testBasicTimer() {
         runBlockingSimulation {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
             scheduler.startSingleTimer(0, 1000) {
-                scheduler.close()
                 assertEquals(1000, clock.millis())
             }
+
+            assertTrue(scheduler.isTimerActive(0))
+            assertFalse(scheduler.isTimerActive(1))
         }
     }
 
@@ -51,7 +60,6 @@ internal class TimerSchedulerTest {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
             scheduler.cancel(1)
-            scheduler.close()
         }
     }
 
@@ -61,12 +69,11 @@ internal class TimerSchedulerTest {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
             scheduler.startSingleTimer(0, 1000) {
-                assertFalse(false)
+                fail()
             }
 
             scheduler.startSingleTimer(1, 100) {
                 scheduler.cancel(0)
-                scheduler.close()
 
                 assertEquals(100, clock.millis())
             }
@@ -78,15 +85,9 @@ internal class TimerSchedulerTest {
         runBlockingSimulation {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
-            scheduler.startSingleTimer(0, 1000) {
-                assertFalse(false)
-            }
-
-            scheduler.startSingleTimer(1, 100) {
-                assertFalse(false)
-            }
-
-            scheduler.close()
+            scheduler.startSingleTimer(0, 1000) { fail() }
+            scheduler.startSingleTimer(1, 100) { fail() }
+            scheduler.cancelAll()
         }
     }
 
@@ -95,12 +96,9 @@ internal class TimerSchedulerTest {
         runBlockingSimulation {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
-            scheduler.startSingleTimer(0, 1000) {
-                assertFalse(false)
-            }
+            scheduler.startSingleTimer(0, 1000) { fail() }
 
             scheduler.startSingleTimer(0, 200) {
-                scheduler.close()
 
                 assertEquals(200, clock.millis())
             }
@@ -108,16 +106,14 @@ internal class TimerSchedulerTest {
     }
 
     @Test
-    fun testStopped() {
+    fun testOverrideBlock() {
         runBlockingSimulation {
             val scheduler = TimerScheduler<Int>(coroutineContext, clock)
 
-            scheduler.close()
+            scheduler.startSingleTimer(0, 1000) { fail() }
 
-            assertThrows<IllegalStateException> {
-                scheduler.startSingleTimer(1, 100) {
-                    assertFalse(false)
-                }
+            scheduler.startSingleTimer(0, 1000) {
+                assertEquals(1000, clock.millis())
             }
         }
     }
@@ -129,11 +125,9 @@ internal class TimerSchedulerTest {
 
             assertThrows<IllegalArgumentException> {
                 scheduler.startSingleTimer(1, -1) {
-                    assertFalse(false)
+                    fail()
                 }
             }
-
-            scheduler.close()
         }
     }
 }
-- 
cgit v1.2.3