Performance optimization by reusing list of listeners instead of merging into a new array

Author: marc-mabe

src/EventManager.php

@@ -164,7 +164,9 @@ public function attach($eventName, callable $listener, $priority = 1)
             ));
         }
 
-        $this->events[$eventName][(int) $priority][] = $listener;
+        // see performance note of triggerListeners() why the internal
+        // event array is structured this way.
+        $this->events[$eventName][(int) $priority][0][] = $listener;
 
         return $listener;
     }
@@ -197,16 +199,16 @@ public function detach(callable $listener, $eventName = null, $force = false)
         }
 
         foreach ($this->events[$eventName] as $priority => $listeners) {
-            foreach ($listeners as $index => $evaluatedListener) {
+            foreach ($listeners[0] as $index => $evaluatedListener) {
                 if ($evaluatedListener !== $listener) {
                     continue;
                 }
 
                 // Found the listener; remove it.
-                unset($this->events[$eventName][$priority][$index]);
+                unset($this->events[$eventName][$priority][0][$index]);
 
                 // If the queue for the given priority is empty, remove it.
-                if (empty($this->events[$eventName][$priority])) {
+                if (empty($this->events[$eventName][$priority][0])) {
                     unset($this->events[$eventName][$priority]);
                     break;
                 }
@@ -262,64 +264,71 @@ protected function triggerListeners(EventInterface $event, callable $callback =
             throw new Exception\RuntimeException('Event is missing a name; cannot trigger!');
         }
 
-        // Initial value of stop propagation flag should be false
-        $event->stopPropagation(false);
-
-        $responses = new ResponseCollection();
-
-        foreach ($this->getListenersByEventName($name) as $listener) {
-            $response = $listener($event);
-            $responses->push($response);
-
-            // If the event was asked to stop propagating, do so
-            if ($event->propagationIsStopped()) {
-                $responses->setStopped(true);
-                break;
-            }
-
-            // If the result causes our validation callback to return true,
-            // stop propagation
-            if ($callback && $callback($response)) {
-                $responses->setStopped(true);
-                break;
-            }
-        }
-
-        return $responses;
-    }
-
-    /**
-     * Get listeners for the currently triggered event.
-     *
-     * @param  string $eventName
-     * @return callable[]
-     */
-    private function getListenersByEventName($eventName)
-    {
-        $listeners = isset($this->events[$eventName]) ? $this->events[$eventName] : [];
+        // Merge all listeners by priority together with format
+        //   [
+        //     <int priority1> => [
+        //       [
+        //         [<callable listener1>, <callable listener2>, ...]
+        //       ],
+        //       ...
+        //     ],
+        //     <int priority2> => [
+        //       [
+        //         [<callable listener1>, <callable listener2>, ...]
+        //       ],
+        //       ...
+        //     ],
+        //     ...
+        //   ]
+        //
+        // PERFORMANCE NOTE:
+        //   This way pushing the list of listeners into a new generated list
+        //   helps us to not call "array_merge_[recursive]"
+        //   and reusing the list of listeners we already have
+        //   instead of iterating over it and generating a new one.
+        //   -> In result it improves performance by up to 25% even if it looks a bit strange.
+        $listOfListenersByPriority = isset($this->events[$name]) ? $this->events[$name] : [];
         if (isset($this->events['*'])) {
             foreach ($this->events['*'] as $p => $l) {
-                $listeners[$p] = isset($listeners[$p]) ? array_merge($listeners[$p], $l) : $l;
+                $listOfListenersByPriority[$p][] = $l[0];
             }
         }
         if ($this->sharedManager) {
-            foreach ($this->sharedManager->getListeners($this->identifiers, $eventName) as $p => $l) {
-                $listeners[$p] = isset($listeners[$p]) ? array_merge($listeners[$p], $l) : $l;
+            foreach ($this->sharedManager->getListeners($this->identifiers, $name) as $p => $l) {
+                $listOfListenersByPriority[$p][] = $l;
             }
         }
 
-        krsort($listeners);
+        // Sort by priority in reverse order
+        krsort($listOfListenersByPriority);
 
-        $listenersForEvent = [];
+        // Initial value of stop propagation flag should be false
+        $event->stopPropagation(false);
 
-        foreach ($listeners as $priority => $listenersByPriority) {
-            foreach ($listenersByPriority as $listener) {
-                // Performance note: after some testing, it appears that accumulating listeners and sending
-                // them at the end of the method is FASTER than using generators (ie. yielding)
-                $listenersForEvent[] = $listener;
+        // Execute listeners
+        $responses = new ResponseCollection();
+        foreach ($listOfListenersByPriority as $listenersList) {
+            foreach ($listenersList as $listeners) {
+                foreach ($listeners as $listener) {
+                    $response = $listener($event);
+                    $responses->push($response);
+
+                    // If the event was asked to stop propagating, do so
+                    if ($event->propagationIsStopped()) {
+                        $responses->setStopped(true);
+                        break 3;
+                    }
+
+                    // If the result causes our validation callback to return true,
+                    // stop propagation
+                    if ($callback && $callback($response)) {
+                        $responses->setStopped(true);
+                        break 3;
+                    }
+                }
             }
         }
 
-        return $listenersForEvent;
+        return $responses;
     }
 }

src/SharedEventManager.php

@@ -190,7 +190,7 @@ public function getListeners(array $identifiers, $eventName)
             }
         }
 
-        if (isset($this->identifiers['*']) && ! in_array('*', $identifiers, true)) {
+        if (isset($this->identifiers['*'])) {
             $wildcardIdentifier = $this->identifiers['*'];
             if (isset($wildcardIdentifier[$eventName])) {
                 foreach ($wildcardIdentifier[$eventName] as $p => $l) {

test/EventManagerTest.php

@@ -56,7 +56,12 @@ public function getListenersForEvent($event, EventManager $manager)
         $r->setAccessible(true);
         $events = $r->getValue($manager);
 
-        return isset($events[$event]) ? $events[$event] : [];
+        $listenersByPriority = isset($events[$event]) ? $events[$event] : [];
+        foreach ($listenersByPriority as $priority => & $listeners) {
+            $listeners = $listeners[0];
+        }
+
+        return $listenersByPriority;
     }
 
     public function testAttachShouldAddListenerToEvent()