Reduce CPU overhead by allowing components to disable their loop() (#9089)

esphome/components/anova/anova.cpp

@@ -17,7 +17,11 @@ void Anova::setup() {
   this->current_request_ = 0;
 }
 
-void Anova::loop() {}
+void Anova::loop() {
+  // Parent BLEClientNode has a loop() method, but this component uses
+  // polling via update() and BLE callbacks so loop isn't needed
+  this->disable_loop();
+}
 
 void Anova::control(const ClimateCall &call) {
   if (call.get_mode().has_value()) {

esphome/components/bedjet/bedjet_hub.cpp

@@ -480,7 +480,11 @@ void BedJetHub::set_clock(uint8_t hour, uint8_t minute) {
 
 /* Internal */
 
-void BedJetHub::loop() {}
+void BedJetHub::loop() {
+  // Parent BLEClientNode has a loop() method, but this component uses
+  // polling via update() and BLE callbacks so loop isn't needed
+  this->disable_loop();
+}
 void BedJetHub::update() { this->dispatch_status_(); }
 
 void BedJetHub::dump_config() {

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -83,7 +83,11 @@ void BedJetClimate::reset_state_() {
   this->publish_state();
 }
 
-void BedJetClimate::loop() {}
+void BedJetClimate::loop() {
+  // This component is controlled via the parent BedJetHub
+  // Empty loop not needed, disable to save CPU cycles
+  this->disable_loop();
+}
 
 void BedJetClimate::control(const ClimateCall &call) {
   ESP_LOGD(TAG, "Received BedJetClimate::control");

esphome/components/ble_client/sensor/ble_rssi_sensor.cpp

@@ -11,7 +11,11 @@ namespace ble_client {
 
 static const char *const TAG = "ble_rssi_sensor";
 
-void BLEClientRSSISensor::loop() {}
+void BLEClientRSSISensor::loop() {
+  // Parent BLEClientNode has a loop() method, but this component uses
+  // polling via update() and BLE GAP callbacks so loop isn't needed
+  this->disable_loop();
+}
 
 void BLEClientRSSISensor::dump_config() {
   LOG_SENSOR("", "BLE Client RSSI Sensor", this);

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -11,7 +11,11 @@ namespace ble_client {
 
 static const char *const TAG = "ble_sensor";
 
-void BLESensor::loop() {}
+void BLESensor::loop() {
+  // Parent BLEClientNode has a loop() method, but this component uses
+  // polling via update() and BLE callbacks so loop isn't needed
+  this->disable_loop();
+}
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -14,7 +14,11 @@ static const char *const TAG = "ble_text_sensor";
 
 static const std::string EMPTY = "";
 
-void BLETextSensor::loop() {}
+void BLETextSensor::loop() {
+  // Parent BLEClientNode has a loop() method, but this component uses
+  // polling via update() and BLE callbacks so loop isn't needed
+  this->disable_loop();
+}
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);

esphome/components/captive_portal/captive_portal.cpp

@@ -37,7 +37,12 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   request->redirect("/?save");
 }
 
-void CaptivePortal::setup() {}
+void CaptivePortal::setup() {
+#ifndef USE_ARDUINO
+  // No DNS server needed for non-Arduino frameworks
+  this->disable_loop();
+#endif
+}
 void CaptivePortal::start() {
   this->base_->init();
   if (!this->initialized_) {
@@ -50,6 +55,8 @@ void CaptivePortal::start() {
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
   this->dns_server_->start(53, "*", ip);
+  // Re-enable loop() when DNS server is started
+  this->enable_loop();
 #endif
 
   this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {

esphome/components/captive_portal/captive_portal.h

@@ -21,8 +21,11 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void dump_config() override;
 #ifdef USE_ARDUINO
   void loop() override {
-    if (this->dns_server_ != nullptr)
+    if (this->dns_server_ != nullptr) {
       this->dns_server_->processNextRequest();
+    } else {
+      this->disable_loop();
+    }
   }
 #endif
   float get_setup_priority() const override;

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -22,6 +22,16 @@ void BLEClientBase::setup() {
   this->connection_index_ = connection_index++;
 }
 
+void BLEClientBase::set_state(espbt::ClientState st) {
+  ESP_LOGV(TAG, "[%d] [%s] Set state %d", this->connection_index_, this->address_str_.c_str(), (int) st);
+  ESPBTClient::set_state(st);
+
+  if (st == espbt::ClientState::READY_TO_CONNECT) {
+    // Enable loop when we need to connect
+    this->enable_loop();
+  }
+}
+
 void BLEClientBase::loop() {
   if (!esp32_ble::global_ble->is_active()) {
     this->set_state(espbt::ClientState::INIT);
@@ -37,9 +47,14 @@ void BLEClientBase::loop() {
   }
   // READY_TO_CONNECT means we have discovered the device
   // and the scanner has been stopped by the tracker.
-  if (this->state_ == espbt::ClientState::READY_TO_CONNECT) {
+  else if (this->state_ == espbt::ClientState::READY_TO_CONNECT) {
     this->connect();
   }
+  // If its idle, we can disable the loop as set_state
+  // will enable it again when we need to connect.
+  else if (this->state_ == espbt::ClientState::IDLE) {
+    this->disable_loop();
+  }
 }
 
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }

esphome/components/esp32_ble_client/ble_client_base.h

@@ -93,6 +93,8 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
 
   bool check_addr(esp_bd_addr_t &addr) { return memcmp(addr, this->remote_bda_, sizeof(esp_bd_addr_t)) == 0; }
 
+  void set_state(espbt::ClientState st) override;
+
  protected:
   int gattc_if_;
   esp_bd_addr_t remote_bda_;

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -168,6 +168,8 @@ void ESP32ImprovComponent::loop() {
     case improv::STATE_PROVISIONED: {
       this->incoming_data_.clear();
       this->set_status_indicator_state_(false);
+      // Provisioning complete, no further loop execution needed
+      this->disable_loop();
       break;
     }
   }
@@ -254,6 +256,7 @@ void ESP32ImprovComponent::start() {
 
   ESP_LOGD(TAG, "Setting Improv to start");
   this->should_start_ = true;
+  this->enable_loop();
 }
 
 void ESP32ImprovComponent::stop() {

esphome/components/online_image/online_image.cpp

@@ -178,18 +178,21 @@ void OnlineImage::update() {
   if (this->format_ == ImageFormat::BMP) {
     ESP_LOGD(TAG, "Allocating BMP decoder");
     this->decoder_ = make_unique<BmpDecoder>(this);
+    this->enable_loop();
   }
 #endif  // USE_ONLINE_IMAGE_BMP_SUPPORT
 #ifdef USE_ONLINE_IMAGE_JPEG_SUPPORT
   if (this->format_ == ImageFormat::JPEG) {
     ESP_LOGD(TAG, "Allocating JPEG decoder");
     this->decoder_ = esphome::make_unique<JpegDecoder>(this);
+    this->enable_loop();
   }
 #endif  // USE_ONLINE_IMAGE_JPEG_SUPPORT
 #ifdef USE_ONLINE_IMAGE_PNG_SUPPORT
   if (this->format_ == ImageFormat::PNG) {
     ESP_LOGD(TAG, "Allocating PNG decoder");
     this->decoder_ = make_unique<PngDecoder>(this);
+    this->enable_loop();
   }
 #endif  // USE_ONLINE_IMAGE_PNG_SUPPORT
 
@@ -212,6 +215,7 @@ void OnlineImage::update() {
 void OnlineImage::loop() {
   if (!this->decoder_) {
     // Not decoding at the moment => nothing to do.
+    this->disable_loop();
     return;
   }
   if (!this->downloader_ || this->decoder_->is_finished()) {

esphome/components/preferences/syncer.h

@@ -12,6 +12,8 @@ class IntervalSyncer : public Component {
   void setup() override {
     if (this->write_interval_ != 0) {
       set_interval(this->write_interval_, []() { global_preferences->sync(); });
+      // When using interval-based syncing, we don't need the loop
+      this->disable_loop();
     }
   }
   void loop() override {

esphome/components/rtttl/rtttl.cpp

@@ -142,8 +142,10 @@ void Rtttl::stop() {
 }
 
 void Rtttl::loop() {
-  if (this->note_duration_ == 0 || this->state_ == State::STATE_STOPPED)
+  if (this->note_duration_ == 0 || this->state_ == State::STATE_STOPPED) {
+    this->disable_loop();
     return;
+  }
 
 #ifdef USE_SPEAKER
   if (this->speaker_ != nullptr) {
@@ -391,6 +393,11 @@ void Rtttl::set_state_(State state) {
   this->state_ = state;
   ESP_LOGV(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
            LOG_STR_ARG(state_to_string(state)));
+
+  // Clear loop_done when transitioning from STOPPED to any other state
+  if (old_state == State::STATE_STOPPED && state != State::STATE_STOPPED) {
+    this->enable_loop();
+  }
 }
 
 }  // namespace rtttl

esphome/components/safe_mode/safe_mode.cpp

@@ -42,6 +42,8 @@ void SafeModeComponent::loop() {
     ESP_LOGI(TAG, "Boot seems successful; resetting boot loop counter");
     this->clean_rtc();
     this->boot_successful_ = true;
+    // Disable loop since we no longer need to check
+    this->disable_loop();
   }
 }
 

esphome/components/sntp/sntp_component.cpp

@@ -67,6 +67,12 @@ void SNTPComponent::loop() {
            time.minute, time.second);
   this->time_sync_callback_.call();
   this->has_time_ = true;
+
+#ifdef USE_ESP_IDF
+  // On ESP-IDF, time sync is permanent and update() doesn't force resync
+  // Time is now synchronized, no need to check anymore
+  this->disable_loop();
+#endif
 }
 
 }  // namespace sntp

esphome/components/tlc5971/tlc5971.cpp

@@ -24,8 +24,10 @@ void TLC5971::dump_config() {
 }
 
 void TLC5971::loop() {
-  if (!this->update_)
+  if (!this->update_) {
+    this->disable_loop();
     return;
+  }
 
   uint32_t command;
 
@@ -93,6 +95,7 @@ void TLC5971::set_channel_value(uint16_t channel, uint16_t value) {
     return;
   if (this->pwm_amounts_[channel] != value) {
     this->update_ = true;
+    this->enable_loop();
   }
   this->pwm_amounts_[channel] = value;
 }

esphome/core/application.cpp

@@ -97,7 +97,13 @@ void Application::loop() {
   // Feed WDT with time
   this->feed_wdt(last_op_end_time);
 
-  for (Component *component : this->looping_components_) {
+  // Mark that we're in the loop for safe reentrant modifications
+  this->in_loop_ = true;
+
+  for (this->current_loop_index_ = 0; this->current_loop_index_ < this->looping_components_active_end_;
+       this->current_loop_index_++) {
+    Component *component = this->looping_components_[this->current_loop_index_];
+
     // Update the cached time before each component runs
     this->loop_component_start_time_ = last_op_end_time;
 
@@ -112,6 +118,8 @@ void Application::loop() {
     this->app_state_ |= new_app_state;
     this->feed_wdt(last_op_end_time);
   }
+
+  this->in_loop_ = false;
   this->app_state_ = new_app_state;
 
   // Use the last component's end time instead of calling millis() again
@@ -235,9 +243,66 @@ void Application::teardown_components(uint32_t timeout_ms) {
 }
 
 void Application::calculate_looping_components_() {
+  // First add all active components
   for (auto *obj : this->components_) {
-    if (obj->has_overridden_loop())
+    if (obj->has_overridden_loop() &&
+        (obj->get_component_state() & COMPONENT_STATE_MASK) != COMPONENT_STATE_LOOP_DONE) {
       this->looping_components_.push_back(obj);
+    }
+  }
+
+  this->looping_components_active_end_ = this->looping_components_.size();
+
+  // Then add all inactive (LOOP_DONE) components
+  // This handles components that called disable_loop() during setup, before this method runs
+  for (auto *obj : this->components_) {
+    if (obj->has_overridden_loop() &&
+        (obj->get_component_state() & COMPONENT_STATE_MASK) == COMPONENT_STATE_LOOP_DONE) {
+      this->looping_components_.push_back(obj);
+    }
+  }
+}
+
+void Application::disable_component_loop_(Component *component) {
+  // This method must be reentrant - components can disable themselves during their own loop() call
+  // Linear search to find component in active section
+  // Most configs have 10-30 looping components (30 is on the high end)
+  // O(n) is acceptable here as we optimize for memory, not complexity
+  for (uint16_t i = 0; i < this->looping_components_active_end_; i++) {
+    if (this->looping_components_[i] == component) {
+      // Move last active component to this position
+      this->looping_components_active_end_--;
+      if (i != this->looping_components_active_end_) {
+        std::swap(this->looping_components_[i], this->looping_components_[this->looping_components_active_end_]);
+
+        // If we're currently iterating and just swapped the current position
+        if (this->in_loop_ && i == this->current_loop_index_) {
+          // Decrement so we'll process the swapped component next
+          this->current_loop_index_--;
+        }
+      }
+      return;
+    }
+  }
+}
+
+void Application::enable_component_loop_(Component *component) {
+  // This method must be reentrant - components can re-enable themselves during their own loop() call
+  // Single pass through all components to find and move if needed
+  // With typical 10-30 components, O(n) is faster than maintaining a map
+  const uint16_t size = this->looping_components_.size();
+  for (uint16_t i = 0; i < size; i++) {
+    if (this->looping_components_[i] == component) {
+      if (i < this->looping_components_active_end_) {
+        return;  // Already active
+      }
+      // Found in inactive section - move to active
+      if (i != this->looping_components_active_end_) {
+        std::swap(this->looping_components_[i], this->looping_components_[this->looping_components_active_end_]);
+      }
+      this->looping_components_active_end_++;
+      return;
+    }
   }
 }
 

esphome/core/application.h

@@ -572,13 +572,41 @@ class Application {
 
   void calculate_looping_components_();
 
+  // These methods are called by Component::disable_loop() and Component::enable_loop()
+  // Components should not call these directly - use this->disable_loop() or this->enable_loop()
+  // to ensure component state is properly updated along with the loop partition
+  void disable_component_loop_(Component *component);
+  void enable_component_loop_(Component *component);
+
   void feed_wdt_arch_();
 
   /// Perform a delay while also monitoring socket file descriptors for readiness
   void yield_with_select_(uint32_t delay_ms);
 
   std::vector<Component *> components_{};
+
+  // Partitioned vector design for looping components
+  // =================================================
+  // Components are partitioned into [active | inactive] sections:
+  //
+  // looping_components_: [A, B, C, D | E, F]
+  //                                  ^
+  //                      looping_components_active_end_ (4)
+  //
+  // - Components A,B,C,D are active and will be called in loop()
+  // - Components E,F are inactive (disabled/failed) and won't be called
+  // - No flag checking needed during iteration - just loop 0 to active_end_
+  // - When a component is disabled, it's swapped with the last active component
+  //   and active_end_ is decremented
+  // - When a component is enabled, it's swapped with the first inactive component
+  //   and active_end_ is incremented
+  // - This eliminates branch mispredictions from flag checking in the hot loop
   std::vector<Component *> looping_components_{};
+  uint16_t looping_components_active_end_{0};
+
+  // For safe reentrant modifications during iteration
+  uint16_t current_loop_index_{0};
+  bool in_loop_{false};
 
 #ifdef USE_BINARY_SENSOR
   std::vector<binary_sensor::BinarySensor *> binary_sensors_{};

esphome/core/component.cpp

@@ -30,17 +30,18 @@ const float LATE = -100.0f;
 
 }  // namespace setup_priority
 
-// Component state uses bits 0-1 (4 states)
-const uint8_t COMPONENT_STATE_MASK = 0x03;
+// Component state uses bits 0-2 (8 states, 5 used)
+const uint8_t COMPONENT_STATE_MASK = 0x07;
 const uint8_t COMPONENT_STATE_CONSTRUCTION = 0x00;
 const uint8_t COMPONENT_STATE_SETUP = 0x01;
 const uint8_t COMPONENT_STATE_LOOP = 0x02;
 const uint8_t COMPONENT_STATE_FAILED = 0x03;
-// Status LED uses bits 2-3
-const uint8_t STATUS_LED_MASK = 0x0C;
+const uint8_t COMPONENT_STATE_LOOP_DONE = 0x04;
+// Status LED uses bits 3-4
+const uint8_t STATUS_LED_MASK = 0x18;
 const uint8_t STATUS_LED_OK = 0x00;
-const uint8_t STATUS_LED_WARNING = 0x04;  // Bit 2
-const uint8_t STATUS_LED_ERROR = 0x08;    // Bit 3
+const uint8_t STATUS_LED_WARNING = 0x08;  // Bit 3
+const uint8_t STATUS_LED_ERROR = 0x10;    // Bit 4
 
 const uint16_t WARN_IF_BLOCKING_OVER_MS = 50U;       ///< Initial blocking time allowed without warning
 const uint16_t WARN_IF_BLOCKING_INCREMENT_MS = 10U;  ///< How long the blocking time must be larger to warn again
@@ -113,6 +114,9 @@ void Component::call() {
     case COMPONENT_STATE_FAILED:  // NOLINT(bugprone-branch-clone)
       // State failed: Do nothing
       break;
+    case COMPONENT_STATE_LOOP_DONE:  // NOLINT(bugprone-branch-clone)
+      // State loop done: Do nothing, component has finished its work
+      break;
     default:
       break;
   }
@@ -136,14 +140,30 @@ bool Component::should_warn_of_blocking(uint32_t blocking_time) {
   return false;
 }
 void Component::mark_failed() {
-  ESP_LOGE(TAG, "Component %s was marked as failed.", this->get_component_source());
+  ESP_LOGE(TAG, "Component %s was marked as failed", this->get_component_source());
   this->component_state_ &= ~COMPONENT_STATE_MASK;
   this->component_state_ |= COMPONENT_STATE_FAILED;
   this->status_set_error();
+  // Also remove from loop since failed components shouldn't loop
+  App.disable_component_loop_(this);
+}
+void Component::disable_loop() {
+  ESP_LOGD(TAG, "%s loop disabled", this->get_component_source());
+  this->component_state_ &= ~COMPONENT_STATE_MASK;
+  this->component_state_ |= COMPONENT_STATE_LOOP_DONE;
+  App.disable_component_loop_(this);
+}
+void Component::enable_loop() {
+  if ((this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_LOOP_DONE) {
+    ESP_LOGD(TAG, "%s loop enabled", this->get_component_source());
+    this->component_state_ &= ~COMPONENT_STATE_MASK;
+    this->component_state_ |= COMPONENT_STATE_LOOP;
+    App.enable_component_loop_(this);
+  }
 }
 void Component::reset_to_construction_state() {
   if ((this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_FAILED) {
-    ESP_LOGI(TAG, "Component %s is being reset to construction state.", this->get_component_source());
+    ESP_LOGI(TAG, "Component %s is being reset to construction state", this->get_component_source());
     this->component_state_ &= ~COMPONENT_STATE_MASK;
     this->component_state_ |= COMPONENT_STATE_CONSTRUCTION;
     // Clear error status when resetting
@@ -276,8 +296,8 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   }
   if (should_warn) {
     const char *src = component_ == nullptr ? "<null>" : component_->get_component_source();
-    ESP_LOGW(TAG, "Component %s took a long time for an operation (%" PRIu32 " ms).", src, blocking_time);
-    ESP_LOGW(TAG, "Components should block for at most 30 ms.");
+    ESP_LOGW(TAG, "Component %s took a long time for an operation (%" PRIu32 " ms)", src, blocking_time);
+    ESP_LOGW(TAG, "Components should block for at most 30 ms");
   }
 
   return curr_time;

esphome/core/component.h

@@ -58,6 +58,7 @@ extern const uint8_t COMPONENT_STATE_CONSTRUCTION;
 extern const uint8_t COMPONENT_STATE_SETUP;
 extern const uint8_t COMPONENT_STATE_LOOP;
 extern const uint8_t COMPONENT_STATE_FAILED;
+extern const uint8_t COMPONENT_STATE_LOOP_DONE;
 extern const uint8_t STATUS_LED_MASK;
 extern const uint8_t STATUS_LED_OK;
 extern const uint8_t STATUS_LED_WARNING;
@@ -150,6 +151,26 @@ class Component {
     this->mark_failed();
   }
 
+  /** Disable this component's loop. The loop() method will no longer be called.
+   *
+   * This is useful for components that only need to run for a certain period of time
+   * or when inactive, saving CPU cycles.
+   *
+   * @note Components should call this->disable_loop() on themselves, not on other components.
+   *       This ensures the component's state is properly updated along with the loop partition.
+   */
+  void disable_loop();
+
+  /** Enable this component's loop. The loop() method will be called normally.
+   *
+   * This is useful for components that transition between active and inactive states
+   * and need to re-enable their loop() method when becoming active again.
+   *
+   * @note Components should call this->enable_loop() on themselves, not on other components.
+   *       This ensures the component's state is properly updated along with the loop partition.
+   */
+  void enable_loop();
+
   bool is_failed() const;
 
   bool is_ready() const;