Add fast alternative for signals and observers (OBSERVABLE_FAST_LIST)

Author: dacap

.github/workflows/build.yml

@@ -8,7 +8,8 @@ jobs:
       matrix:
         os: [windows-latest, macos-latest, ubuntu-latest]
         build_type: [debug,release]
-        benchmark: [false]
+        benchmark: [tests]
+        fast: [safe, fast]
         sanitizer: [""]
         include:
           - os: macos-latest
@@ -19,7 +20,12 @@ jobs:
             sanitizer: "-fsanitize=address"
           - os: ubuntu-latest
             build_type: release
-            benchmark: true
+            benchmark: benchmark
+            fast: safe
+          - os: ubuntu-latest
+            build_type: release
+            benchmark: benchmark
+            fast: fast
     steps:
     - uses: actions/checkout@v4
     - uses: aseprite/get-ninja@main
@@ -28,15 +34,26 @@ jobs:
     - name: Generating Makefiles
       shell: bash
       run: |
+        if [[ "${{ matrix.benchmark }}" == "benchmark" ]] ; then
+          OBSERVABLE_BENCHMARKS=ON
+        else
+          OBSERVABLE_BENCHMARKS=OFF
+        fi
+        if [[ "${{ matrix.fast }}" == fast ]] ; then
+          OBSERVABLE_FAST_LIST=ON
+        else
+          OBSERVABLE_FAST_LIST=OFF
+        fi
         cmake . -G Ninja \
           -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
           -DCMAKE_CXX_FLAGS=${{ matrix.sanitizer }}  \
           -DCMAKE_EXE_LINKER_FLAGS=${{ matrix.sanitizer }} \
-          -DOBSERVABLE_BENCHMARKS=${{ matrix.benchmark }}
+          -DOBSERVABLE_FAST_LIST=$OBSERVABLE_FAST_LIST \
+          -DOBSERVABLE_BENCHMARKS=$OBSERVABLE_BENCHMARKS
     - name: Compiling
       run: cmake --build .
     - name: Running Tests
       shell: bash
       run: |
         ctest --output-on-failure
-        if [[ "${{ matrix.benchmark }}" == "true" ]] ; then ./benchmarks/obs_benchmarks ; fi
+        if [[ "${{ matrix.benchmark }}" == "benchmark" ]] ; then ./benchmarks/obs_benchmarks ; fi

CMakeLists.txt

@@ -1,11 +1,12 @@
 # Observable Library
-# Copyright (C) 2016-2025 David Capello
+# Copyright (C) 2016-present David Capello
 
 cmake_minimum_required(VERSION 3.15)
 
 project(observable CXX)
 option(OBSERVABLE_TESTS "Compile observable tests" ON)
 option(OBSERVABLE_BENCHMARKS "Compile observable benchmarks" OFF)
+option(OBSERVABLE_FAST_LIST "Use fast list (non-thread safe) instead of safe (thread-safe) one by default" OFF)
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -17,6 +18,10 @@ endif()
 add_library(obs obs/connection.cpp)
 target_include_directories(obs PUBLIC .)
 
+if(OBSERVABLE_FAST_LIST)
+  target_compile_definitions(obs PUBLIC OBSERVABLE_FAST_LIST)
+endif()
+
 if(OBSERVABLE_TESTS)
   enable_testing()
   add_subdirectory(tests)

README.md

@@ -1,7 +1,7 @@
 Observable Library
 ==================
 
-*Copyright (C) 2016-2025 David Capello*
+*Copyright (C) 2016-present David Capello*
 
 [![build](https://github.com/dacap/observable/actions/workflows/build.yml/badge.svg)](https://github.com/dacap/observable/actions/workflows/build.yml)
 [![MIT Licensed](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
@@ -70,9 +70,21 @@ int main() {
 }
 ```
 
-Tested Compilers
+Safe vs Fast
 ----------------
 
-* Visual Studio 2015
-* Xcode 7.3.1 (`-std=c++11`)
-* GCC 4.8.4 (`-std=c++11`)
+There are two variants of signals and observers:
+
+* `obs::safe_signal` vs `obs::fast_signal`
+* `obs::safe_observers` vs `obs::fast_observers`
+
+The only difference between both is that the "fast" version uses
+`obs::fast_list` instead of `obs::safe_list`, where the former keeps
+track of slots with a `std::vector` and the later one is a thread-safe
+version list to connect/disconnect slots from different threads.
+
+By default and for backward compatibility, `obs::signal` and
+`obs::observers` use the safe version, but you can enable the
+`OBSERVABLE_FAST_LIST` option to switch from `obs::safe_list` to
+`obs::fast_list` which is recommended for most cases (e.g. you don't
+need to do strange connections/disconnections as in [tests](tests)).

benchmarks/obs_benchmarks.cpp

@@ -54,7 +54,7 @@ static void BM_ObsSignal(benchmark::State& state) {
 BENCHMARK(BM_ObsSignal)->Range(1, 1024);
 
 static void BM_ObsThreads(benchmark::State& state) {
-  obs::signal<void()> sig;
+  obs::safe_signal<void()> sig;
   for (auto _ : state) {
     state.PauseTiming();
     std::vector<std::thread> threads;

obs.h

@@ -8,6 +8,7 @@
 #define OBS_H_INCLUDED
 #pragma once
 
+#include "obs/lists.h"
 #include "obs/observable.h"
 #include "obs/observers.h"
 #include "obs/signal.h"

obs/connection.cpp

@@ -1,12 +1,14 @@
 // Observable Library
-// Copyright (c) 2016 David Capello
+// Copyright (c) 2016-present David Capello
 //
 // This file is released under the terms of the MIT license.
 // Read LICENSE.txt for more information.
 
 #include "obs/connection.h"
 #include "obs/signal.h"
 
+#include <cassert>
+
 namespace obs {
 
 void connection::disconnect() {

obs/fast_list.h

@@ -0,0 +1,44 @@
+// Observable Library
+// Copyright (c) 2026-present David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef OBS_FAST_LIST_H_INCLUDED
+#define OBS_FAST_LIST_H_INCLUDED
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+
+namespace obs {
+
+template<typename T>
+class fast_list {
+  std::vector<T*> m_list;
+
+public:
+  using iterator = typename std::vector<T*>::iterator;
+
+  fast_list() = default;
+  ~fast_list() = default;
+
+  bool empty() const { return m_list.empty(); }
+  iterator begin() { return m_list.begin(); }
+  iterator end() { return m_list.end(); }
+
+  void push_back(T* value) {
+    m_list.push_back(value);
+  }
+
+  void erase(T* value) {
+    auto it = std::find(m_list.begin(), m_list.end(), value);
+    if (it != m_list.end())
+      m_list.erase(it);
+  }
+};
+
+} // namespace obs
+
+#endif

obs/lists.h

@@ -0,0 +1,26 @@
+// Observable Library
+// Copyright (c) 2026-present David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef OBS_LISTS_H_INCLUDED
+#define OBS_LISTS_H_INCLUDED
+#pragma once
+
+#include "obs/fast_list.h"
+#include "obs/safe_list.h"
+
+namespace obs {
+
+#ifdef OBSERVABLE_FAST_LIST
+  template<typename T>
+  using default_list = fast_list<T>;
+#else
+  template<typename T>
+  using default_list = safe_list<T>;
+#endif
+
+} // namespace obs
+
+#endif

obs/observable.h

@@ -1,5 +1,5 @@
 // Observable Library
-// Copyright (c) 2016 David Capello
+// Copyright (c) 2016-present David Capello
 //
 // This file is released under the terms of the MIT license.
 // Read LICENSE.txt for more information.
@@ -12,7 +12,7 @@
 
 namespace obs {
 
-template<typename Observer>
+template<typename Observer, typename List = observers<Observer, default_list>>
 class observable {
 public:
 
@@ -34,9 +34,15 @@ class observable {
   }
 
 private:
-  observers<Observer> m_observers;
+  List m_observers;
 };
 
+template<typename Observer>
+using fast_observable = observable<Observer, fast_observers<Observer>>;
+
+template<typename Observer>
+using safe_observable = observable<Observer, safe_observers<Observer>>;
+
 } // namespace obs
 
 #endif

obs/observers.h

@@ -8,15 +8,15 @@
 #define OBS_OBSERVERS_H_INCLUDED
 #pragma once
 
-#include "obs/safe_list.h"
+#include "obs/lists.h"
 
 namespace obs {
 
-template<typename T>
+template<typename T, template<typename> class List = default_list>
 class observers {
 public:
   using observer_type = T;
-  using list_type = safe_list<observer_type>;
+  using list_type = List<observer_type>;
   using iterator = typename list_type::iterator;
 
   bool empty() const { return m_observers.empty(); }
@@ -42,6 +42,12 @@ class observers {
   list_type m_observers;
 };
 
+template<typename T>
+using fast_observers = observers<T, fast_list>;
+
+template<typename T>
+using safe_observers = observers<T, safe_list>;
+
 } // namespace obs
 
 #endif