Merge pull request #74 from basiliscos/v0.37-dev

V0.37 dev

Author: basiliscos

CMakeLists.txt

@@ -1,8 +1,8 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.17)
 
 cmake_policy(SET CMP0074 NEW)
 
-set(ROTOR_VERSION "0.36")
+set(ROTOR_VERSION "0.37")
 project (rotor LANGUAGES CXX VERSION ${ROTOR_VERSION})
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")

README.md

@@ -67,6 +67,14 @@ project.
 
 ## Changelog
 
+### 0.37 (14-Dec-2025)
+ - [feature, asio, thread, ev] allow poll-duration to be set to zero save CPU cycles/battery
+ - [cmake, breaking] increase cmake version requirement `3.15` -> `3.17`
+ - [cmake] generate file for clangd langserv (thanks for @rymdbar)
+ - [cosmetic] removed trailing spaces (thanks for @rymdbar)
+ - [cosmetic] fixed identation to make sources more vim-folding friendly (thanks for @rymdbar)
+ - [cosmetic] configure linters to project style (thanks for @rymdbar)
+
 ### 0.36 (14-Oct-2025)
  - [feature] add `route()` and `redirect()` high-level actor methods, which
    provide convenient API over `make_routed_message()` introduced in `v0.32`

docs/Changelog.md

@@ -4,6 +4,14 @@
 [reliable]: https://en.wikipedia.org/wiki/Reliability_(computer_networking) "reliable"
 [request-response]: https://en.wikipedia.org/wiki/Request%E2%80%93response
 
+### 0.37 (14-Dec-2025)
+ - [feature, asio, thread, ev] allow poll-duration to be set to zero save CPU cycles/battery
+ - [cmake, breaking] increase cmake version requirement `3.15` -> `3.17`
+ - [cmake] generate file for clangd langserv (thanks for @rymdbar)
+ - [cosmetic] removed trailing spaces (thanks for @rymdbar)
+ - [cosmetic] fixed identation to make sources more vim-folding friendly (thanks for @rymdbar)
+ - [cosmetic] configure linters to project style (thanks for @rymdbar)
+
 ### 0.36 (14-Oct-2025)
  - [feature] add `route()` and `redirect()` high-level actor methods, which
    provide convenient API over `make_routed_message()` introduced in `v0.32`

doxygen

@@ -117,13 +117,17 @@ struct ponger_t : public r::actor_base_t {
 };
 
 int main(int argc, char **argv) {
-
+    using boost::conversion::try_lexical_convert;
     asio::io_context io_ctx1;
     asio::io_context io_ctx2;
     try {
         std::uint32_t count = 10000;
+        std::uint32_t poll_us = 100;
         if (argc > 1) {
-            boost::conversion::try_lexical_convert(argv[1], count);
+            try_lexical_convert(argv[1], count);
+            if (argc > 2) {
+                try_lexical_convert(argv[2], poll_us);
+            }
         }
 
         auto sys_ctx1 = ra::system_context_asio_t::ptr_t{new ra::system_context_asio_t(io_ctx1)};
@@ -134,11 +138,13 @@ int main(int argc, char **argv) {
         auto sup1 = sys_ctx1->create_supervisor<ra::supervisor_asio_t>()
                         .strand(strand1)
                         .timeout(timeout)
+                        .poll_duration(r::pt::milliseconds{poll_us})
                         .guard_context(true)
                         .finish();
         auto sup2 = sys_ctx2->create_supervisor<ra::supervisor_asio_t>()
                         .strand(strand2)
                         .timeout(timeout)
+                        .poll_duration(r::pt::milliseconds{poll_us})
                         .guard_context(true)
                         .finish();
 

examples/boost-asio/ping-pong-2-threads.cpp

@@ -113,20 +113,29 @@ struct ponger_t : public r::actor_base_t {
 
 int main(int argc, char **argv) {
     try {
+        using boost::conversion::try_lexical_convert;
         std::uint32_t count = 10000;
+        std::uint32_t poll_us = 100;
         if (argc > 1) {
-            boost::conversion::try_lexical_convert(argv[1], count);
+            try_lexical_convert(argv[1], count);
+            if (argc > 2) {
+                try_lexical_convert(argv[2], poll_us);
+            }
         }
 
         rth::system_context_thread_t ctx_ping;
         rth::system_context_thread_t ctx_pong;
         auto timeout = boost::posix_time::milliseconds{100};
-        auto sup_ping =
-            ctx_ping.create_supervisor<rth::supervisor_thread_t>().timeout(timeout).create_registry().finish();
+        auto sup_ping = ctx_ping.create_supervisor<rth::supervisor_thread_t>()
+                .poll_duration(r::pt::milliseconds{poll_us})
+                .timeout(timeout)
+                .create_registry()
+                .finish();
         auto pinger = sup_ping->create_actor<pinger_t>().autoshutdown_supervisor().timeout(timeout).finish();
         pinger->set_pings(count);
 
         auto sup_pong = ctx_pong.create_supervisor<rth::supervisor_thread_t>()
+                            .poll_duration(r::pt::milliseconds{poll_us})
                             .timeout(timeout)
                             .registry_address(sup_ping->get_registry_address())
                             .finish();

examples/thread/ping-pong-thread.cpp

@@ -49,10 +49,10 @@ struct supervisor_config_t : actor_config_t {
      * \brief How much time it will spend in polling inbound queue before switching into
      * sleep mode (i.e. waiting external messages).
      *
-     * This value might affect I/O latency on event-loops, so set it to zero to
-     * minimizer I/O latency on event-loops by the rising cross-thread rotor messaging
-     * latency.
-     *
+     * Under the hood this value instructs how much time rotor spends in spin-locks
+     * waiting messages (and burning CPU). If there is no large cross-thread
+     * messages traffic (i.e. < 100k messages per second) or there is need to
+     * save battery, set this value to zero for root supervisors.
      */
     pt::time_duration poll_duration = pt::millisec{1};
 

include/rotor/supervisor_config.h

@@ -118,8 +118,9 @@ void supervisor_asio_t::do_process() noexcept {
         enqueued_messages = supervisor_t::do_process();
     }
 
-    if (enqueued_messages) {
-        auto deadline = clock_t::now() + time_units_t{poll_duration.total_microseconds()};
+    auto total_microsecs = poll_duration.total_microseconds();
+    if (total_microsecs && enqueued_messages) {
+        auto deadline = clock_t::now() + time_units_t{total_microsecs};
         while (clock_t::now() < deadline && leader_queue.empty()) {
             while (inbound.pop(ptr)) {
                 leader_queue.emplace_back(ptr, false);

src/rotor/asio/supervisor_asio.cpp

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2019-2024 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
+// Copyright (c) 2019-2025 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
 //
 // Distributed under the MIT Software License
 //
@@ -124,7 +124,7 @@ void supervisor_ev_t::on_async() noexcept {
         enqueued_messages = do_process();
     }
 
-    if (enqueued_messages) {
+    if (poll_duration > 0 && enqueued_messages) {
         ev_now_update(loop);
         auto now = ev_now(loop);
         auto deadline = now + poll_duration;

src/rotor/ev/supervisor_ev.cpp

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2019-2021 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
+// Copyright (c) 2019-2025 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
 //
 // Distributed under the MIT Software License
 //
@@ -52,19 +52,23 @@ void system_context_thread_t::run() noexcept {
         return false;
     };
 
-    auto delta = time_units_t{poll_duration.total_microseconds()};
+    auto total_us = poll_duration.total_microseconds();
+    auto delta = time_units_t{total_us};
     while (condition()) {
         root_sup.do_process();
         if (condition()) {
-            using namespace std::chrono_literals;
             auto dealine = clock_t::now() + delta;
             if (!timer_nodes.empty()) {
                 dealine = std::min(dealine, timer_nodes.front().deadline);
             }
-            // fast stage, indirect spin-lock, cpu consuming
-            while ((clock_t::now() < dealine) && !process()) {
+            if (total_us) {
+                // fast stage, indirect spin-lock, cpu consuming
+                while ((clock_t::now() < dealine) && !process());
+            } else {
+                while (!process());
             }
             if (queue.empty()) {
+                using namespace std::chrono_literals;
                 std::unique_lock<std::mutex> lock(mutex);
                 auto predicate = [&]() { return !inbound.empty(); };
                 // wait notification, do not consume CPU