[EventLoop] Implement timers for the stream_select() based loop.

nrk · nrk · commit 30441ec46b39 · 2012-05-11T00:37:12.000+02:00
Timers can be one-shot or periodic and both are cancellable by using the
signature returned when adding them to the event loop. Periodic timers
can be cancelled also by returing FALSE from the provided callback.

The event loop will continue to run even without any registered stream
until there is at least one timer scheduled for execution or the loop
is explicitly stopped.
diff --git a/StreamSelectLoop.php b/StreamSelectLoop.php
@@ -2,22 +2,22 @@
 
 namespace React\EventLoop;
 
+use React\EventLoop\Timer\Timers;
+
 class StreamSelectLoop implements LoopInterface
 {
-    private $timeout;
+    const QUANTUM_INTERVAL = 1000000;
 
+    private $timers;
+    private $running = false;
     private $readStreams = array();
     private $readListeners = array();
-
     private $writeStreams = array();
     private $writeListeners = array();
 
-    private $stopped = false;
-
-    // timeout = microseconds
-    public function __construct($timeout = 1000000)
+    public function __construct()
     {
-        $this->timeout = $timeout;
+        $this->timers = new Timers();
     }
 
     public function addReadStream($stream, $listener)
@@ -66,17 +66,61 @@ public function removeStream($stream)
         $this->removeWriteStream($stream);
     }
 
-    public function tick()
+    public function addTimer($interval, $callback)
+    {
+        return $this->timers->add($interval, $callback);
+    }
+
+    public function addPeriodicTimer($interval, $callback)
+    {
+        return $this->timers->add($interval, $callback, true);
+    }
+
+    public function cancelTimer($signature)
+    {
+        $this->timers->cancel($signature);
+    }
+
+    protected function getNextEventTime()
+    {
+        $nextEvent = $this->timers->getFirst();
+
+        if ($nextEvent === -1) {
+            return self::QUANTUM_INTERVAL;
+        }
+
+        $currentTime = microtime(true);
+        if ($nextEvent > $currentTime) {
+            return ($nextEvent - $currentTime) * 1000000;
+        }
+
+        return 0;
+    }
+
+    protected function sleepOnPendingTimers()
+    {
+        if ($this->timers->isEmpty()) {
+            $this->running = false;
+        } else {
+            // We use usleep() instead of stream_select() to emulate timeouts
+            // since the latter fails when there are no streams registered for
+            // read / write events. Blame PHP for us needing this hack.
+            usleep($this->getNextEventTime());
+        }
+    }
+
+    protected function runStreamSelect()
     {
         $read = $this->readStreams ?: null;
         $write = $this->writeStreams ?: null;
-        $excepts = null;
+        $except = null;
 
         if (!$read && !$write) {
-            return false;
+            $this->sleepOnPendingTimers();
+            return;
         }
 
-        if (stream_select($read, $write, $except, 0, $this->timeout) > 0) {
+        if (stream_select($read, $write, $except, 0, $this->getNextEventTime()) > 0) {
             if ($read) {
                 foreach ($read as $stream) {
                     $listener = $this->readListeners[(int) $stream];
@@ -99,16 +143,22 @@ public function tick()
                 }
             }
         }
+    }
+
+    public function tick()
+    {
+        $this->timers->run();
+        $this->runStreamSelect();
 
-        return true;
+        return $this->running;
     }
 
     public function run()
     {
         // @codeCoverageIgnoreStart
-        $this->stopped = false;
+        $this->running = true;
 
-        while ($this->tick() === true && !$this->stopped) {
+        while ($this->tick()) {
             // NOOP
         }
         // @codeCoverageIgnoreEnd
@@ -117,7 +167,7 @@ public function run()
     public function stop()
     {
         // @codeCoverageIgnoreStart
-        $this->stopped = true;
+        $this->running = false;
         // @codeCoverageIgnoreEnd
     }
 }
diff --git a/Timer/Timers.php b/Timer/Timers.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace React\EventLoop\Timer;
+
+class Timers
+{
+    const MIN_RESOLUTION = 0.001;
+
+    private $time;
+    private $active;
+    private $timers;
+
+    public function __construct()
+    {
+        $this->time = 0;
+        $this->active = array();
+        $this->timers = new \SplPriorityQueue();
+    }
+
+    public function updateTime()
+    {
+        return $this->time = microtime(true);
+    }
+
+    public function getTime()
+    {
+        return $this->time ?: $this->updateTime();
+    }
+
+    public function add($interval, $callback, $periodic = false)
+    {
+        if ($interval < self::MIN_RESOLUTION) {
+            throw new \InvalidArgumentException('Timer events do not support sub-millisecond timeouts.');
+        }
+
+        if (!is_callable($callback)) {
+            throw new \InvalidArgumentException('The callback must be a callable object.');
+        }
+
+        $interval = (float) $interval;
+
+        $timer = (object) array(
+            'interval' => $interval,
+            'callback' => $callback,
+            'periodic' => $periodic,
+            'scheduled' => $interval + $this->getTime(),
+        );
+
+        $signature = $timer->signature = spl_object_hash($timer);
+        $this->timers->insert($timer, -$timer->scheduled);
+        $this->active[$signature] = $timer;
+
+        return $signature;
+    }
+
+    public function cancel($signature)
+    {
+        unset($this->active[$signature]);
+    }
+
+    public function getFirst()
+    {
+        if ($this->timers->isEmpty()) {
+            return -1;
+        }
+
+        return $this->timers->top()->scheduled;
+    }
+
+    public function isEmpty()
+    {
+        return !$this->active;
+    }
+
+    public function run()
+    {
+        $time = $this->updateTime();
+        $timers = $this->timers;
+
+        while (!$timers->isEmpty() && $timers->top()->scheduled < $time) {
+            $timer = $timers->extract();
+
+            if (isset($this->active[$timer->signature])) {
+                $rearm = call_user_func($timer->callback);
+
+                if ($timer->periodic === true && $rearm !== false) {
+                    $timer->scheduled = $timer->interval + $time;
+                    $this->timers->insert($timer, -$timer->scheduled);
+                } else {
+                    unset($this->active[$timer->signature]);
+                }
+            }
+        }
+    }
+}
