Optimize socket operations by checking readiness in the main loop (#8918)

esphome/core/application.cpp

@@ -2,11 +2,30 @@
 #include "esphome/core/log.h"
 #include "esphome/core/version.h"
 #include "esphome/core/hal.h"
+#include <algorithm>
 
 #ifdef USE_STATUS_LED
 #include "esphome/components/status_led/status_led.h"
 #endif
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+#include <cerrno>
+
+#ifdef USE_SOCKET_IMPL_LWIP_SOCKETS
+// LWIP sockets implementation
+#include <lwip/sockets.h>
+#elif defined(USE_SOCKET_IMPL_BSD_SOCKETS)
+// BSD sockets implementation
+#ifdef USE_ESP32
+// ESP32 "BSD sockets" are actually LWIP under the hood
+#include <lwip/sockets.h>
+#else
+// True BSD sockets (e.g., host platform)
+#include <sys/select.h>
+#endif
+#endif
+#endif
+
 namespace esphome {
 
 static const char *const TAG = "app";
@@ -106,7 +125,65 @@ void Application::loop() {
     // otherwise interval=0 schedules result in constant looping with almost no sleep
     next_schedule = std::max(next_schedule, delay_time / 2);
     delay_time = std::min(next_schedule, delay_time);
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+    if (!this->socket_fds_.empty()) {
+      // Use select() with timeout when we have sockets to monitor
+
+      // Update fd_set if socket list has changed
+      if (this->socket_fds_changed_) {
+        FD_ZERO(&this->base_read_fds_);
+        for (int fd : this->socket_fds_) {
+          if (fd >= 0 && fd < FD_SETSIZE) {
+            FD_SET(fd, &this->base_read_fds_);
+          }
+        }
+        this->socket_fds_changed_ = false;
+      }
+
+      // Copy base fd_set before each select
+      this->read_fds_ = this->base_read_fds_;
+
+      // Convert delay_time (milliseconds) to timeval
+      struct timeval tv;
+      tv.tv_sec = delay_time / 1000;
+      tv.tv_usec = (delay_time - tv.tv_sec * 1000) * 1000;
+
+      // Call select with timeout
+#if defined(USE_SOCKET_IMPL_LWIP_SOCKETS) || (defined(USE_ESP32) && defined(USE_SOCKET_IMPL_BSD_SOCKETS))
+      // Use lwip_select() on platforms with lwIP - it's faster
+      // Note: On ESP32 with BSD sockets, select() is already mapped to lwip_select() via macros,
+      // but we explicitly call lwip_select() for clarity and to ensure we get the optimized version
+      int ret = lwip_select(this->max_fd_ + 1, &this->read_fds_, nullptr, nullptr, &tv);
+#else
+      // Use standard select() on other platforms (e.g., host/native builds)
+      int ret = ::select(this->max_fd_ + 1, &this->read_fds_, nullptr, nullptr, &tv);
+#endif
+
+      if (ret < 0) {
+        if (errno == EINTR) {
+          // Interrupted by signal - this is normal, just continue
+          // No need to delay as some time has already passed
+          ESP_LOGVV(TAG, "select() interrupted by signal");
+        } else {
+          // Actual error - log and fall back to delay
+          ESP_LOGW(TAG, "select() failed with errno %d", errno);
+          delay(delay_time);
+        }
+      } else if (ret > 0) {
+        ESP_LOGVV(TAG, "select() woke early: %d socket(s) ready (saved up to %ums)", ret, delay_time);
+      } else {
+        // ret == 0: timeout occurred (normal)
+        ESP_LOGVV(TAG, "select() timeout after %ums (no sockets ready)", delay_time);
+      }
+    } else {
+      // No sockets registered, use regular delay
+      delay(delay_time);
+    }
+#else
+    // No select support, use regular delay
     delay(delay_time);
+#endif
   }
   this->last_loop_ = last_op_end_time;
 
@@ -167,6 +244,67 @@ void Application::calculate_looping_components_() {
   }
 }
 
+#ifdef USE_SOCKET_SELECT_SUPPORT
+bool Application::register_socket_fd(int fd) {
+  // WARNING: This function is NOT thread-safe and must only be called from the main loop
+  // It modifies socket_fds_ and related variables without locking
+  if (fd < 0)
+    return false;
+
+  if (fd >= FD_SETSIZE) {
+    ESP_LOGE(TAG, "Cannot monitor socket fd %d: exceeds FD_SETSIZE (%d)", fd, FD_SETSIZE);
+    ESP_LOGE(TAG, "Socket will not be monitored for data - may cause performance issues!");
+    return false;
+  }
+
+  this->socket_fds_.push_back(fd);
+  this->socket_fds_changed_ = true;
+
+  if (fd > this->max_fd_) {
+    this->max_fd_ = fd;
+  }
+
+  return true;
+}
+
+void Application::unregister_socket_fd(int fd) {
+  // WARNING: This function is NOT thread-safe and must only be called from the main loop
+  // It modifies socket_fds_ and related variables without locking
+  if (fd < 0)
+    return;
+
+  auto it = std::find(this->socket_fds_.begin(), this->socket_fds_.end(), fd);
+  if (it != this->socket_fds_.end()) {
+    // Swap with last element and pop - O(1) removal since order doesn't matter
+    if (it != this->socket_fds_.end() - 1) {
+      std::swap(*it, this->socket_fds_.back());
+    }
+    this->socket_fds_.pop_back();
+    this->socket_fds_changed_ = true;
+
+    // Only recalculate max_fd if we removed the current max
+    if (fd == this->max_fd_) {
+      if (this->socket_fds_.empty()) {
+        this->max_fd_ = -1;
+      } else {
+        // Find new max using std::max_element
+        this->max_fd_ = *std::max_element(this->socket_fds_.begin(), this->socket_fds_.end());
+      }
+    }
+  }
+}
+
+bool Application::is_socket_ready(int fd) const {
+  // This function is thread-safe for reading the result of select()
+  // However, it should only be called after select() has been executed in the main loop
+  // The read_fds_ is only modified by select() in the main loop
+  if (fd < 0 || fd >= FD_SETSIZE)
+    return false;
+
+  return FD_ISSET(fd, &this->read_fds_);
+}
+#endif
+
 Application App;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace esphome