[core] Eliminate global constructor overhead for component vectors

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

esphome/components/cs5460a/cs5460a.h

@@ -76,7 +76,6 @@ class CS5460AComponent : public Component,
   void restart() { restart_(); }
 
   void setup() override;
-  void loop() override {}
   void dump_config() override;
 
  protected:

esphome/components/debug/debug_esp8266.cpp

@@ -3,80 +3,21 @@
 #include "esphome/core/log.h"
 #include <Esp.h>
 
-extern "C" {
-#include <user_interface.h>
-
-// Global reset info struct populated by SDK at boot
-extern struct rst_info resetInfo;
-
-// Core version - either a string pointer or a version number to format as hex
-extern uint32_t core_version;
-extern const char *core_release;
-}
-
 namespace esphome {
 namespace debug {
 
 static const char *const TAG = "debug";
 
-// Get reset reason string from reason code (no heap allocation)
-// Returns LogString* pointing to flash (PROGMEM) on ESP8266
-static const LogString *get_reset_reason_str(uint32_t reason) {
-  switch (reason) {
-    case REASON_DEFAULT_RST:
-      return LOG_STR("Power On");
-    case REASON_WDT_RST:
-      return LOG_STR("Hardware Watchdog");
-    case REASON_EXCEPTION_RST:
-      return LOG_STR("Exception");
-    case REASON_SOFT_WDT_RST:
-      return LOG_STR("Software Watchdog");
-    case REASON_SOFT_RESTART:
-      return LOG_STR("Software/System restart");
-    case REASON_DEEP_SLEEP_AWAKE:
-      return LOG_STR("Deep-Sleep Wake");
-    case REASON_EXT_SYS_RST:
-      return LOG_STR("External System");
-    default:
-      return LOG_STR("Unknown");
-  }
-}
-
-// Size for core version hex buffer
-static constexpr size_t CORE_VERSION_BUFFER_SIZE = 12;
-
-// Get core version string (no heap allocation)
-// Returns either core_release directly or formats core_version as hex into provided buffer
-static const char *get_core_version_str(std::span<char, CORE_VERSION_BUFFER_SIZE> buffer) {
-  if (core_release != nullptr) {
-    return core_release;
-  }
-  snprintf_P(buffer.data(), CORE_VERSION_BUFFER_SIZE, PSTR("%08x"), core_version);
-  return buffer.data();
-}
-
-// Size for reset info buffer
-static constexpr size_t RESET_INFO_BUFFER_SIZE = 200;
-
-// Get detailed reset info string (no heap allocation)
-// For watchdog/exception resets, includes detailed exception info
-static const char *get_reset_info_str(std::span<char, RESET_INFO_BUFFER_SIZE> buffer, uint32_t reason) {
-  if (reason >= REASON_WDT_RST && reason <= REASON_SOFT_WDT_RST) {
-    snprintf_P(buffer.data(), RESET_INFO_BUFFER_SIZE,
-               PSTR("Fatal exception:%d flag:%d (%s) epc1:0x%08x epc2:0x%08x epc3:0x%08x excvaddr:0x%08x depc:0x%08x"),
-               static_cast<int>(resetInfo.exccause), static_cast<int>(reason),
-               LOG_STR_ARG(get_reset_reason_str(reason)), resetInfo.epc1, resetInfo.epc2, resetInfo.epc3,
-               resetInfo.excvaddr, resetInfo.depc);
-    return buffer.data();
-  }
-  return LOG_STR_ARG(get_reset_reason_str(reason));
-}
-
 const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // Copy from flash to provided buffer
-  strncpy_P(buffer.data(), (PGM_P) get_reset_reason_str(resetInfo.reason), RESET_REASON_BUFFER_SIZE - 1);
-  buffer[RESET_REASON_BUFFER_SIZE - 1] = '\0';
-  return buffer.data();
+  char *buf = buffer.data();
+#if !defined(CLANG_TIDY)
+  String reason = ESP.getResetReason();  // NOLINT
+  snprintf_P(buf, RESET_REASON_BUFFER_SIZE, PSTR("%s"), reason.c_str());
+  return buf;
+#else
+  buf[0] = '\0';
+  return buf;
+#endif
 }
 
 const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
@@ -92,42 +33,37 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
 
-  const LogString *flash_mode;
+  const char *flash_mode;
   switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
     case FM_QIO:
-      flash_mode = LOG_STR("QIO");
+      flash_mode = "QIO";
       break;
     case FM_QOUT:
-      flash_mode = LOG_STR("QOUT");
+      flash_mode = "QOUT";
       break;
     case FM_DIO:
-      flash_mode = LOG_STR("DIO");
+      flash_mode = "DIO";
       break;
     case FM_DOUT:
-      flash_mode = LOG_STR("DOUT");
+      flash_mode = "DOUT";
       break;
     default:
-      flash_mode = LOG_STR("UNKNOWN");
+      flash_mode = "UNKNOWN";
   }
-  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT(readability-static-accessed-through-instance)
-  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT(readability-static-accessed-through-instance)
-  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed,
-           LOG_STR_ARG(flash_mode));
+  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
+  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
+  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
   pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                          LOG_STR_ARG(flash_mode));
+                          flash_mode);
 
+#if !defined(CLANG_TIDY)
   char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(reason_buffer);
-  char core_version_buffer[CORE_VERSION_BUFFER_SIZE];
-  char reset_info_buffer[RESET_INFO_BUFFER_SIZE];
-  // NOLINTBEGIN(readability-static-accessed-through-instance)
+  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
   uint32_t chip_id = ESP.getChipId();
   uint8_t boot_version = ESP.getBootVersion();
   uint8_t boot_mode = ESP.getBootMode();
   uint8_t cpu_freq = ESP.getCpuFreqMHz();
   uint32_t flash_chip_id = ESP.getFlashChipId();
-  const char *sdk_version = ESP.getSdkVersion();
-  // NOLINTEND(readability-static-accessed-through-instance)
 
   ESP_LOGD(TAG,
            "Chip ID: 0x%08" PRIX32 "\n"
@@ -138,18 +74,19 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            "Flash Chip ID=0x%08" PRIX32 "\n"
            "Reset Reason: %s\n"
            "Reset Info: %s",
-           chip_id, sdk_version, get_core_version_str(core_version_buffer), boot_version, boot_mode, cpu_freq,
-           flash_chip_id, reset_reason, get_reset_info_str(reset_info_buffer, resetInfo.reason));
+           chip_id, ESP.getSdkVersion(), ESP.getCoreVersion().c_str(), boot_version, boot_mode, cpu_freq, flash_chip_id,
+           reset_reason, ESP.getResetInfo().c_str());
 
   pos = buf_append_printf(buf, size, pos, "|Chip: 0x%08" PRIX32, chip_id);
-  pos = buf_append_printf(buf, size, pos, "|SDK: %s", sdk_version);
-  pos = buf_append_printf(buf, size, pos, "|Core: %s", get_core_version_str(core_version_buffer));
+  pos = buf_append_printf(buf, size, pos, "|SDK: %s", ESP.getSdkVersion());
+  pos = buf_append_printf(buf, size, pos, "|Core: %s", ESP.getCoreVersion().c_str());
   pos = buf_append_printf(buf, size, pos, "|Boot: %u", boot_version);
   pos = buf_append_printf(buf, size, pos, "|Mode: %u", boot_mode);
   pos = buf_append_printf(buf, size, pos, "|CPU: %u", cpu_freq);
   pos = buf_append_printf(buf, size, pos, "|Flash: 0x%08" PRIX32, flash_chip_id);
   pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|%s", get_reset_info_str(reset_info_buffer, resetInfo.reason));
+  pos = buf_append_printf(buf, size, pos, "|%s", ESP.getResetInfo().c_str());
+#endif
 
   return pos;
 }

esphome/components/lock/lock.cpp

@@ -28,16 +28,14 @@ const LogString *lock_state_to_string(LockState state) {
 Lock::Lock() : state(LOCK_STATE_NONE) {}
 LockCall Lock::make_call() { return LockCall(this); }
 
-void Lock::lock() {
+void Lock::set_state_(LockState state) {
   auto call = this->make_call();
-  call.set_state(LOCK_STATE_LOCKED);
-  this->control(call);
-}
-void Lock::unlock() {
-  auto call = this->make_call();
-  call.set_state(LOCK_STATE_UNLOCKED);
+  call.set_state(state);
   this->control(call);
 }
+
+void Lock::lock() { this->set_state_(LOCK_STATE_LOCKED); }
+void Lock::unlock() { this->set_state_(LOCK_STATE_UNLOCKED); }
 void Lock::open() {
   if (traits.get_supports_open()) {
     ESP_LOGD(TAG, "'%s' Opening.", this->get_name().c_str());

esphome/components/lock/lock.h

@@ -156,6 +156,9 @@ class Lock : public EntityBase {
  protected:
   friend LockCall;
 
+  /// Helper for lock/unlock convenience methods
+  void set_state_(LockState state);
+
   /** Perform the open latch action with hardware. This method is optional to implement
    * when creating a new lock.
    *

esphome/components/mapping/mapping.h

@@ -2,6 +2,7 @@
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include <cinttypes>
 #include <map>
 #include <string>
 
@@ -43,8 +44,17 @@ template<typename K, typename V> class Mapping {
       esph_log_e(TAG, "Key '%p' not found in mapping", key);
     } else if constexpr (std::is_same_v<K, std::string>) {
       esph_log_e(TAG, "Key '%s' not found in mapping", key.c_str());
+    } else if constexpr (std::is_integral_v<K>) {
+      char buf[24];  // enough for 64-bit integer
+      if constexpr (std::is_unsigned_v<K>) {
+        buf_append_printf(buf, sizeof(buf), 0, "%" PRIu64, static_cast<uint64_t>(key));
+      } else {
+        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, static_cast<int64_t>(key));
+      }
+      esph_log_e(TAG, "Key '%s' not found in mapping", buf);
     } else {
-      esph_log_e(TAG, "Key '%s' not found in mapping", to_string(key).c_str());
+      // All supported key types are handled above - this should never be reached
+      static_assert(sizeof(K) == 0, "Unsupported key type for Mapping error logging");
     }
     return {};
   }

esphome/components/mqtt/mqtt_client.cpp

@@ -403,6 +403,12 @@ void MQTTClientComponent::loop() {
 
         this->last_connected_ = now;
         this->resubscribe_subscriptions_();
+
+        // Process pending resends for all MQTT components centrally
+        // This is more efficient than each component polling in its own loop
+        for (MQTTComponent *component : this->children_) {
+          component->process_resend();
+        }
       }
       break;
   }

esphome/components/mqtt/mqtt_component.cpp

@@ -308,16 +308,12 @@ void MQTTComponent::call_setup() {
   }
 }
 
-void MQTTComponent::call_loop() {
-  if (this->is_internal())
+void MQTTComponent::process_resend() {
+  // Called by MQTTClientComponent when connected to process pending resends
+  // Note: is_internal() check not needed - internal components are never registered
+  if (!this->resend_state_)
     return;
 
-  this->loop();
-
-  if (!this->resend_state_ || !this->is_connected_()) {
-    return;
-  }
-
   this->resend_state_ = false;
   if (this->is_discovery_enabled()) {
     if (!this->send_discovery_()) {

esphome/components/mqtt/mqtt_component.h

@@ -81,8 +81,6 @@ class MQTTComponent : public Component {
   /// Override setup_ so that we can call send_discovery() when needed.
   void call_setup() override;
 
-  void call_loop() override;
-
   void call_dump_config() override;
 
   /// Send discovery info the Home Assistant, override this.
@@ -133,6 +131,9 @@ class MQTTComponent : public Component {
   /// Internal method for the MQTT client base to schedule a resend of the state on reconnect.
   void schedule_resend_state();
 
+  /// Process pending resend if needed (called by MQTTClientComponent)
+  void process_resend();
+
   /** Send a MQTT message.
    *
    * @param topic The topic.

esphome/components/statsd/statsd.cpp

@@ -114,14 +114,22 @@ void StatsdComponent::update() {
     // This implies you can't explicitly set a gauge to a negative number without first setting it to zero.
     if (val < 0) {
       if (this->prefix_) {
-        out.append(str_sprintf("%s.", this->prefix_));
+        out.append(this->prefix_);
+        out.append(".");
       }
-      out.append(str_sprintf("%s:0|g\n", s.name));
+      out.append(s.name);
+      out.append(":0|g\n");
     }
     if (this->prefix_) {
-      out.append(str_sprintf("%s.", this->prefix_));
+      out.append(this->prefix_);
+      out.append(".");
     }
-    out.append(str_sprintf("%s:%f|g\n", s.name, val));
+    out.append(s.name);
+    // Buffer for ":" + value + "|g\n".
+    // %f with -DBL_MAX can produce up to 321 chars, plus ":" and "|g\n" (4) + null = 326
+    char val_buf[330];
+    buf_append_printf(val_buf, sizeof(val_buf), 0, ":%f|g\n", val);
+    out.append(val_buf);
 
     if (out.length() > SEND_THRESHOLD) {
       this->send_(&out);

esphome/components/x9c/x9c.cpp

@@ -6,7 +6,7 @@ namespace x9c {
 
 static const char *const TAG = "x9c.output";
 
-void X9cOutput::trim_value(int change_amount) {
+void X9cOutput::trim_value(int32_t change_amount) {
   if (change_amount == 0) {
     return;
   }
@@ -47,17 +47,17 @@ void X9cOutput::setup() {
 
   if (this->initial_value_ <= 0.50) {
     this->trim_value(-101);  // Set min value (beyond 0)
-    this->trim_value(static_cast<uint32_t>(roundf(this->initial_value_ * 100)));
+    this->trim_value(lroundf(this->initial_value_ * 100));
   } else {
     this->trim_value(101);  // Set max value (beyond 100)
-    this->trim_value(static_cast<uint32_t>(roundf(this->initial_value_ * 100) - 100));
+    this->trim_value(lroundf(this->initial_value_ * 100) - 100);
   }
   this->pot_value_ = this->initial_value_;
   this->write_state(this->initial_value_);
 }
 
 void X9cOutput::write_state(float state) {
-  this->trim_value(static_cast<uint32_t>(roundf((state - this->pot_value_) * 100)));
+  this->trim_value(lroundf((state - this->pot_value_) * 100));
   this->pot_value_ = state;
 }
 

esphome/components/x9c/x9c.h

@@ -18,7 +18,7 @@ class X9cOutput : public output::FloatOutput, public Component {
   void setup() override;
   void dump_config() override;
 
-  void trim_value(int change_amount);
+  void trim_value(int32_t change_amount);
 
  protected:
   void write_state(float state) override;

esphome/core/component.cpp

@@ -47,18 +47,21 @@ struct ComponentPriorityOverride {
 };
 
 // Error messages for failed components
+// Using raw pointer instead of unique_ptr to avoid global constructor/destructor overhead
+// This is never freed as error messages persist for the lifetime of the device
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::unique_ptr<std::vector<ComponentErrorMessage>> component_error_messages;
+std::vector<ComponentErrorMessage> *component_error_messages = nullptr;
 // Setup priority overrides - freed after setup completes
+// Using raw pointer instead of unique_ptr to avoid global constructor/destructor overhead
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::unique_ptr<std::vector<ComponentPriorityOverride>> setup_priority_overrides;
+std::vector<ComponentPriorityOverride> *setup_priority_overrides = nullptr;
 
 // Helper to store error messages - reduces duplication between deprecated and new API
 // Remove before 2026.6.0 when deprecated const char* API is removed
 void store_component_error_message(const Component *component, const char *message, bool is_flash_ptr) {
   // Lazy allocate the error messages vector if needed
   if (!component_error_messages) {
-    component_error_messages = std::make_unique<std::vector<ComponentErrorMessage>>();
+    component_error_messages = new std::vector<ComponentErrorMessage>();
   }
   // Check if this component already has an error message
   for (auto &entry : *component_error_messages) {
@@ -467,7 +470,7 @@ float Component::get_actual_setup_priority() const {
 void Component::set_setup_priority(float priority) {
   // Lazy allocate the vector if needed
   if (!setup_priority_overrides) {
-    setup_priority_overrides = std::make_unique<std::vector<ComponentPriorityOverride>>();
+    setup_priority_overrides = new std::vector<ComponentPriorityOverride>();
     // Reserve some space to avoid reallocations (most configs have < 10 overrides)
     setup_priority_overrides->reserve(10);
   }
@@ -553,7 +556,8 @@ WarnIfComponentBlockingGuard::~WarnIfComponentBlockingGuard() {}
 
 void clear_setup_priority_overrides() {
   // Free the setup priority map completely
-  setup_priority_overrides.reset();
+  delete setup_priority_overrides;
+  setup_priority_overrides = nullptr;
 }
 
 }  // namespace esphome