Use atomic list for event subscribers

Summary:
Replace the *copy on write* vector with an atomic pointer to a linked list.

This allows to publish without locking a mutex, at the cost of the slower traversal of a linked list (a vector has better locality).

At the moment, the typical use case is to have one subscriber, meaning that the afforementioned slower traversal is not a problem.

Adding subscribers is implemented as atomic *compare and swap.*

Reviewed By: SidharthGuglani

Differential Revision: D15546964

fbshipit-source-id: 41bfa41f1ac6be5c9b6bf4288ea3271ee995877e

ReactCommon/yoga/yoga/event/event.cpp

@@ -5,51 +5,57 @@
  * file in the root directory of this source tree.
  */
 #include "event.h"
+#include <atomic>
 #include <memory>
 #include <stdexcept>
-#include <mutex>
-
-#include <iostream>
 
 namespace facebook {
 namespace yoga {
 
 namespace {
 
-std::mutex& eventSubscribersMutex() {
- static std::mutex subscribersMutex;
- return subscribersMutex;
-}
+struct Node {
+ std::function<Event::Subscriber> subscriber = nullptr;
+ Node* next = nullptr;
+
+ Node(std::function<Event::Subscriber>&& subscriber)
+ : subscriber{std::move(subscriber)} {}
+};
 
-std::shared_ptr<Event::Subscribers>& eventSubscribers() {
- static auto subscribers = std::make_shared<Event::Subscribers>();
- return subscribers;
+std::atomic<Node*> subscribers{nullptr};
+
+Node* push(Node* newHead) {
+ Node* oldHead;
+ do {
+ oldHead = subscribers.load(std::memory_order_relaxed);
+ if (newHead != nullptr) {
+ newHead->next = oldHead;
+ }
+ } while (!subscribers.compare_exchange_weak(
+ oldHead, newHead, std::memory_order_release, std::memory_order_relaxed));
+ return oldHead;
 }
 
 } // namespace
 
 void Event::reset() {
- eventSubscribers() = std::make_shared<Event::Subscribers>();
+ auto head = push(nullptr);
+ while (head != nullptr) {
+ auto current = head;
+ head = head->next;
+ delete current;
+ }
 }
 
 void Event::subscribe(std::function<Subscriber>&& subscriber) {
- std::lock_guard<std::mutex> guard(eventSubscribersMutex());
- eventSubscribers() =
- std::make_shared<Event::Subscribers>(*eventSubscribers());
- eventSubscribers()->push_back(subscriber);
+ push(new Node{std::move(subscriber)});
 }
 
 void Event::publish(const YGNode& node, Type eventType, const Data& eventData) {
- std::shared_ptr<Event::Subscribers> subscribers;
- {
- std::lock_guard<std::mutex> guard(eventSubscribersMutex());
- subscribers = eventSubscribers();
- }
-
- for (auto& subscriber : *subscribers) {
- if (subscriber) {
- subscriber(node, eventType, eventData);
- }
+ for (auto subscriber = subscribers.load(std::memory_order_relaxed);
+ subscriber != nullptr;
+ subscriber = subscriber->next) {
+ subscriber->subscriber(node, eventType, eventData);
  }
 }