[EventLoop] Reimplement timers for StreamSelectLoop.

nrk · nrk · commit e37b2a5eebae · 2013-01-12T18:01:34.000+01:00
diff --git a/LoopInterface.php b/LoopInterface.php
@@ -13,7 +13,7 @@ public function removeStream($stream);
 
     public function addTimer($interval, $callback);
     public function addPeriodicTimer($interval, $callback);
-    public function cancelTimer($signature);
+    public function cancelTimer($timer);
 
     public function tick();
     public function run();
diff --git a/StreamSelectLoop.php b/StreamSelectLoop.php
@@ -2,6 +2,8 @@
 
 namespace React\EventLoop;
 
+use React\EventLoop\Timer\Timer;
+use React\EventLoop\Timer\TimerInterface;
 use React\EventLoop\Timer\Timers;
 
 class StreamSelectLoop implements LoopInterface
@@ -17,7 +19,7 @@ class StreamSelectLoop implements LoopInterface
 
     public function __construct()
     {
-        $this->timers = new Timers($this);
+        $this->timers = new Timers();
     }
 
     public function addReadStream($stream, $listener)
@@ -68,17 +70,23 @@ public function removeStream($stream)
 
     public function addTimer($interval, $callback)
     {
-        return $this->timers->add($interval, $callback);
+        $timer = new Timer($this, $interval, $callback, false);
+        $this->timers->add($timer);
+
+        return $timer;
     }
 
     public function addPeriodicTimer($interval, $callback)
     {
-        return $this->timers->add($interval, $callback, true);
+        $timer = new Timer($this, $interval, $callback, true);
+        $this->timers->add($timer);
+
+        return $timer;
     }
 
-    public function cancelTimer($signature)
+    public function cancelTimer($timer)
     {
-        $this->timers->cancel($signature);
+        $this->timers->cancel($timer);
     }
 
     protected function getNextEventTimeInMicroSeconds()
diff --git a/Timer/Timers.php b/Timer/Timers.php
@@ -2,21 +2,23 @@
 
 namespace React\EventLoop\Timer;
 
+use SplObjectStorage;
+use SplPriorityQueue;
+use InvalidArgumentException;
 use React\EventLoop\LoopInterface;
 
 class Timers
 {
     const MIN_RESOLUTION = 0.001;
 
-    private $loop;
     private $time;
-    private $active = array();
     private $timers;
+    private $scheduler;
 
-    public function __construct(LoopInterface $loop)
+    public function __construct()
     {
-        $this->loop = $loop;
-        $this->timers = new \SplPriorityQueue();
+        $this->timers = new SplObjectStorage();
+        $this->scheduler = new SplPriorityQueue();
     }
 
     public function updateTime()
@@ -29,68 +31,69 @@ public function getTime()
         return $this->time ?: $this->updateTime();
     }
 
-    public function add($interval, $callback, $periodic = false)
+    public function add(TimerInterface $timer)
     {
-        if ($interval < self::MIN_RESOLUTION) {
-            throw new \InvalidArgumentException('Timer events do not support sub-millisecond timeouts.');
-        }
+        $interval = $timer->getInterval();
 
-        if (!is_callable($callback)) {
-            throw new \InvalidArgumentException('The callback must be a callable object.');
+        if ($interval < self::MIN_RESOLUTION) {
+            throw new InvalidArgumentException('Timer events do not support sub-millisecond timeouts.');
         }
 
-        $interval = (float) $interval;
+        $scheduledAt = $interval + $this->getTime();
 
-        $timer = (object) array(
-            'interval' => $interval,
-            'callback' => $callback,
-            'periodic' => $periodic,
-            'scheduled' => $interval + $this->getTime(),
-        );
-
-        $timer->signature = spl_object_hash($timer);
-        $this->timers->insert($timer, -$timer->scheduled);
-        $this->active[$timer->signature] = $timer;
-
-        return $timer->signature;
+        $this->timers->attach($timer, $scheduledAt);
+        $this->scheduler->insert($timer, -$scheduledAt);
     }
 
-    public function cancel($signature)
+    public function cancel(TimerInterface $timer)
     {
-        unset($this->active[$signature]);
+        $this->timers->detach($timer);
     }
 
     public function getFirst()
     {
-        if ($this->timers->isEmpty()) {
+        if ($this->scheduler->isEmpty()) {
             return null;
         }
 
-        return $this->timers->top()->scheduled;
+        $scheduledAt = $this->timers[$this->scheduler->top()];
+
+        return $scheduledAt;
     }
 
     public function isEmpty()
     {
-        return !$this->active;
+        return count($this->timers) === 0;
     }
 
     public function tick()
     {
         $time = $this->updateTime();
         $timers = $this->timers;
+        $scheduler = $this->scheduler;
 
-        while (!$timers->isEmpty() && $timers->top()->scheduled < $time) {
-            $timer = $timers->extract();
+        while ($scheduler->isEmpty() === false) {
+            $timer = $scheduler->top();
+
+            if (isset($timers[$timer]) === false) {
+                $scheduler->extract();
+                $timers->detach($timer);
+
+                continue;
+            }
+
+            if ($timers[$timer] >= $time) {
+                break;
+            }
 
-            if (isset($this->active[$timer->signature])) {
-                call_user_func($timer->callback, $timer->signature, $this->loop);
+            $scheduler->extract();
+            call_user_func($timer->getCallback(), $timer);
 
-                if ($timer->periodic === true) {
-                    $timer->scheduled = $timer->interval + $time;
-                    $timers->insert($timer, -$timer->scheduled);
-                } else {
-                    unset($this->active[$timer->signature]);
-                }
+            if ($timer->isPeriodic() && isset($timers[$timer])) {
+                $timers[$timer] = $scheduledAt = $timer->getInterval() + $time;
+                $scheduler->insert($timer, -$scheduledAt);
+            } else {
+                $timers->detach($timer);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`
`3`	`3`	`namespace React\EventLoop;`
`4`	`4`
	`5`	`+use React\EventLoop\Timer\Timer;`
	`6`	`+use React\EventLoop\Timer\TimerInterface;`
`5`	`7`	`use React\EventLoop\Timer\Timers;`
`6`	`8`
`7`	`9`	`class StreamSelectLoop implements LoopInterface`
`@@ -17,7 +19,7 @@ class StreamSelectLoop implements LoopInterface`
`17`	`19`
`18`	`20`	`public function __construct()`
`19`	`21`	`{`
`20`		`- $this->timers = new Timers($this);`
	`22`	`+ $this->timers = new Timers();`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`public function addReadStream($stream, $listener)`
`@@ -68,17 +70,23 @@ public function removeStream($stream)`
`68`	`70`
`69`	`71`	`public function addTimer($interval, $callback)`
`70`	`72`	`{`
`71`		`- return $this->timers->add($interval, $callback);`
	`73`	`+ $timer = new Timer($this, $interval, $callback, false);`
	`74`	`+ $this->timers->add($timer);`
	`75`	`+`
	`76`	`+ return $timer;`
`72`	`77`	`}`
`73`	`78`
`74`	`79`	`public function addPeriodicTimer($interval, $callback)`
`75`	`80`	`{`
`76`		`- return $this->timers->add($interval, $callback, true);`
	`81`	`+ $timer = new Timer($this, $interval, $callback, true);`
	`82`	`+ $this->timers->add($timer);`
	`83`	`+`
	`84`	`+ return $timer;`
`77`	`85`	`}`
`78`	`86`
`79`		`- public function cancelTimer($signature)`
	`87`	`+ public function cancelTimer($timer)`
`80`	`88`	`{`
`81`		`- $this->timers->cancel($signature);`
	`89`	`+ $this->timers->cancel($timer);`
`82`	`90`	`}`
`83`	`91`
`84`	`92`	`protected function getNextEventTimeInMicroSeconds()`