Merge pull request #24 from scala-native/rewrite-timer

Rewrite Timer to be more performant

Author: lolgab

build.sbt

@@ -44,6 +44,9 @@ lazy val commonSettings = Seq(
     "-Ywarn-unused-import"
   ),
   Compile / doc / scalacOptions -= "-Xfatal-warnings",
+  libraryDependencies += "com.lihaoyi" %%% "utest" % "0.7.5-SNAPSHOT" % Test,
+  testFrameworks += new TestFramework("utest.runner.Framework"),
+  Test / nativeLinkStubs := true,
   publish / skip := true,
   publishLocal / skip := true
 )

core/loop.scala

@@ -47,6 +47,7 @@ object EventLoop {
 @link("uv")
 @extern
 object LibUV {
+  type UVHandle      = Ptr[Byte]
   type PipeHandle    = Ptr[Byte]
   type PollHandle    = Ptr[Ptr[Byte]]
   type TCPHandle     = Ptr[Byte]
@@ -66,7 +67,7 @@ object LibUV {
   type WriteCB      = CFuncPtr2[WriteReq, Int, Unit]
   type PrepareCB    = CFuncPtr1[PrepareHandle, Unit]
   type ShutdownCB   = CFuncPtr2[ShutdownReq, Int, Unit]
-  type CloseCB      = CFuncPtr1[TCPHandle, Unit]
+  type CloseCB      = CFuncPtr1[UVHandle, Unit]
   type PollCB       = CFuncPtr3[PollHandle, Int, Int, Unit]
   type TimerCB      = CFuncPtr1[TimerHandle, Unit]
   type FSCB         = CFuncPtr1[FSReq, Unit]
@@ -77,6 +78,8 @@ object LibUV {
   def uv_loop_close(loop: Loop): CInt                             = extern
   def uv_is_active(handle: Ptr[Byte]): Int                        = extern
   def uv_handle_size(h_type: Int): CSize                          = extern
+  def uv_handle_get_data(handle: Ptr[Byte]): Long                 = extern
+  def uv_handle_set_data(handle: Ptr[Byte], data: Long): Unit     = extern
   def uv_req_size(r_type: Int): CSize                             = extern
   def uv_prepare_init(loop: Loop, handle: PrepareHandle): Int     = extern
   def uv_prepare_start(handle: PrepareHandle, cb: PrepareCB): Int = extern

core/src/main/scala/scala/scalanative/loop/HandleUtils.scala

@@ -0,0 +1,36 @@
+package scala.scalanative.loop
+
+import scala.scalanative.runtime.Intrinsics._
+import scala.scalanative.unsafe.Ptr
+import scala.scalanative.libc.stdlib
+import scala.collection.mutable
+import LibUV._
+
+private [loop] object HandleUtils {
+  private val references = mutable.Map.empty[Long, Int]
+
+  @inline def getData[T <: Object](handle: Ptr[Byte]): T = {
+    val data = LibUV.uv_handle_get_data(handle)
+    val rawptr = castLongToRawPtr(data)
+    castRawPtrToObject(rawptr).asInstanceOf[T]
+  }
+  @inline def setData[T <: Object](handle: Ptr[Byte], function: T): Unit = {
+    val rawptr = castObjectToRawPtr(function)
+    val data = castRawPtrToLong(rawptr)
+    if(references.contains(data)) references(data) += 1
+    else references(data) = 1
+    LibUV.uv_handle_set_data(handle, data)
+  }
+  private val onCloseCB = new CloseCB {
+    def apply(handle: UVHandle): Unit = {
+      stdlib.free(handle)
+    }
+  }
+  @inline def close(handle: Ptr[Byte]): Unit = {
+    uv_close(handle, onCloseCB)
+    val data = LibUV.uv_handle_get_data(handle)
+    val current = references(data)
+    if(current > 1) references(data) -= 1
+    else references.remove(data)
+  }
+}

core/src/main/scala/scala/scalanative/loop/Timer.scala

@@ -0,0 +1,52 @@
+package scala.scalanative.loop
+
+import scala.scalanative.libc.stdlib
+import scala.concurrent.{Future, Promise}
+import scala.concurrent.duration._
+import LibUV._, LibUVConstants._
+import scala.scalanative.unsafe.Ptr
+
+@inline class Timer private (private val ptr: Ptr[Byte]) extends AnyVal {
+  def clear(): Unit = {
+    uv_timer_stop(ptr)
+    HandleUtils.close(ptr)
+  }
+}
+
+object Timer {
+  private val timeoutCB = new TimerCB {
+    def apply(handle: TimerHandle): Unit = {
+      val callback = HandleUtils.getData[() => Unit](handle)
+      callback.apply()
+      new Timer(handle)
+    }
+  }
+  private val repeatCB = new TimerCB {
+    def apply(handle: TimerHandle): Unit = {
+      val callback = HandleUtils.getData[() => Unit](handle)
+      callback.apply()
+    }
+  }
+  @inline
+  private def startTimer(timeout: Long, repeat: Long, callback: () => Unit): Timer = {
+    val timerHandle = stdlib.malloc(uv_handle_size(UV_TIMER_T))
+    uv_timer_init(EventLoop.loop, timerHandle)
+    HandleUtils.setData(timerHandle, callback)
+    uv_timer_start(timerHandle, timeoutCB, timeout, repeat)
+    new Timer(timerHandle)
+  }
+
+  def delay(duration: FiniteDuration): Future[Unit] = {
+    val promise = Promise[Unit]()
+    timeout(duration.toMillis)(() => promise.success(()))
+    promise.future
+  }
+
+  def timeout(millis: Long)(callback: () => Unit): Timer = {
+    startTimer(millis, 0L, callback)
+  }
+
+  def repeat(millis: Long)(callback: () => Unit): Timer = {
+    startTimer(millis, millis, callback)
+  }
+}

core/src/test/scala/scala/scalanative/loop/TimerTests.scala

@@ -0,0 +1,46 @@
+package scala.scalanative.loop
+
+import utest._
+import scala.concurrent.duration._
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Promise
+
+object TimerTests extends TestSuite {
+  val tests = Tests {
+    def now(): Duration = System.currentTimeMillis().millis
+    val d = 200.millis
+    test("delay") {
+      var i = 0
+      val startTime = now()
+      def checkDelay(time: Int) = {
+        i += 1
+        assert(i == time)
+        assert(now() - startTime >= d * time)
+      }
+      for {
+        () <- Timer.delay(d)
+        _ = checkDelay(1)
+        () <- Timer.delay(d)
+        _ = checkDelay(2)
+      } yield ()
+    }
+    test("repeat") {
+      var i = 0
+      val startTime = now()
+      val times = 3
+      val p = Promise[Unit]()
+      var timer: Timer = null.asInstanceOf[Timer]
+      timer = Timer.repeat(d.toMillis) { () =>
+        if(i == times) {
+          p.success(())
+          timer.clear()
+        } else i += 1
+      }
+      p.future.map { _ =>
+        assert(i == times)
+        val took = now() - startTime
+        assert(took >= d * 3)
+      }
+    }
+  }
+}

core/timer.scala

@@ -12,10 +12,7 @@
 
 package scala.scalajs.js.timers
 
-import scalanative.libc.stdlib
 import scalanative.loop.Timer
-import scalanative.loop.LibUV.uv_timer_stop
-import scalanative.loop.LibUVConstants.check
 
 /**
  *  <span class="badge badge-non-std" style="float: right;">Non-Standard</span>
@@ -34,22 +31,8 @@ object RawTimers {
    *  @return A handle that can be used to cancel the timeout by passing it
    *          to [[clearTimeout]].
    */
-  def setTimeout(handler: () => Unit, interval: Double): SetTimeoutHandle = {
-    val t = Timer.oneTime(interval, handler)
-    new SetTimeoutHandle {
-      val timerHandle = t
-    }
-  }
-
-  /** Cancel a timeout execution
-   *  @param handle The handle returned by [[setTimeout]]
-   */
-  def clearTimeout(handle: SetTimeoutHandle): Unit = {
-    if (handle.timerHandle != null) {
-      check(uv_timer_stop(handle.timerHandle), "uv_timer_stop")
-      stdlib.free(handle.timerHandle)
-    }
-  }
+  @inline def setTimeout(handler: () => Unit, interval: Double): SetTimeoutHandle =
+    Timer.timeout(interval.toLong)(handler)
 
   /** Schedule `handler` for repeated execution every `interval`
    *  milliseconds.
@@ -59,20 +42,6 @@ object RawTimers {
    *  @return A handle that can be used to cancel the interval by passing it
    *          to [[clearInterval]].
    */
-  def setInterval(handler: () => Unit, interval: Double): SetIntervalHandle = {
-    val t = Timer.repeat(interval, handler)
-    new SetIntervalHandle {
-      val timerHandle = t
-    }
-  }
-
-  /** Cancel an interval execution
-   *  @param handle The handle returned by [[setInterval]]
-   */
-  def clearInterval(handle: SetIntervalHandle): Unit = {
-    if (handle.timerHandle != null) {
-      check(uv_timer_stop(handle.timerHandle), "uv_timer_stop")
-      stdlib.free(handle.timerHandle)
-    }
-  }
+  @inline def setInterval(handler: () => Unit, interval: Double): SetIntervalHandle =
+    Timer.repeat(interval.toLong)(handler)
 }

scalajs-compat/Handles.scala

@@ -24,6 +24,11 @@ import scala.concurrent.duration.FiniteDuration
  */
 package object timers {
 
+  import scala.scalanative.loop.Timer
+
+  type SetTimeoutHandle = Timer 
+  type SetIntervalHandle = Timer 
+
   /** Schedule something for execution in `interval` milliseconds.
    *
    *  @param interval duration in milliseconds to wait
@@ -32,8 +37,9 @@ package object timers {
    *          to [[clearTimeout]].
    *  @note Uses JavaScript's non-standard `setTimeout`
    */
-  def setTimeout(interval: Double)(body: => Unit): SetTimeoutHandle =
+  def setTimeout(interval: Double)(body: => Unit): SetTimeoutHandle = {
     RawTimers.setTimeout(() => body, interval)
+  }
 
   /** Schedule something for execution after a duration.
    *
@@ -43,16 +49,16 @@ package object timers {
    *          to [[clearTimeout]].
    *  @note Uses JavaScript's non-standard `setTimeout`
    */
-  def setTimeout(interval: FiniteDuration)(body: => Unit): SetTimeoutHandle =
+  def setTimeout(interval: FiniteDuration)(body: => Unit): SetTimeoutHandle = {
     RawTimers.setTimeout(() => body, interval.toMillis.toDouble)
+  }
 
   /** Cancel a timeout execution
    *  @param handle The handle returned by
    *         [[setTimeout(interval:scala\.concurrent\.duration\.FiniteDuration)* setTimeout]].
    *  @note Uses JavaScript's non-standard `clearTimeout`
    */
-  def clearTimeout(handle: SetTimeoutHandle): Unit =
-    RawTimers.clearTimeout(handle)
+  def clearTimeout(handle: SetTimeoutHandle): Unit = handle.clear()
 
   /** Schedule something for repeated execution every `interval` milliseconds.
    *
@@ -82,6 +88,6 @@ package object timers {
    *  @note Uses JavaScript's non-standard `clearInterval`
    */
   def clearInterval(handle: SetIntervalHandle): Unit =
-    RawTimers.clearInterval(handle)
+    handle.clear()
 
 }