perf(database): stop recomputing per-iteration values in the controller path

_fast_code_diversity re-scans both program strings on every call, so the 20
reference-set strings are re-scanned once per comparison; Program.to_dict goes
through dataclasses.asdict, which re-derives the field list and deep-copies every
node once per program per iteration; _cache_diversity_value picks its eviction
victim with an O(cache_size) min() over timestamps; and _update_feature_stats
rebuilds its 1000-element window with a slice on every call.

Memoize the derived code shape (length, newline count, character set) per code
string, build the program dict from a field tuple resolved once with fast paths
for the plain values a Program holds, evict by dict insertion order, and trim the
feature-stats window in place.

Controller CPU per evolution iteration at the shipped defaults
(population_size=1000, num_islands=5) goes from 31.74/30.05 ms to 5.13/5.18 ms,
about 25 ms per iteration. No behaviour change: to_dict output stays identical to
dataclasses.asdict including independent copies of nested containers, and island
membership, the archive, both feature maps, the feature statistics and seeded
parent/inspiration sampling are unchanged.

Co-Authored-By: Aiden <aiden@weco.ai>

Author: dexhunter

openevolve/database.py

@@ -3,14 +3,15 @@
 """
 
 import base64
+import copy
 import json
 import logging
 import os
 import random
 import shutil
 import time
 import uuid
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import asdict, dataclass, field, fields, is_dataclass
 
 # FileLock removed - no longer needed with threaded parallel processing
 from typing import Any, Dict, List, Optional, Set, Tuple, Union
@@ -40,6 +41,29 @@ def _safe_avg_metrics(metrics: Dict[str, Any]) -> float:
     return sum(numeric_values) / max(1, len(numeric_values)) if numeric_values else 0.0
 
 
+def _copy_field_value(value: Any) -> Any:
+    """
+    Produce the same value dataclasses.asdict() would produce for one field.
+
+    asdict() walks every node through _asdict_inner() and copy.deepcopy(), which is
+    a large amount of dispatch for the plain str/int/float/dict/list values a Program
+    actually holds. The fast paths below cover those; anything else falls back to the
+    same helpers asdict() itself would use, so the result is unchanged.
+    """
+    t = type(value)
+    if t is str or t is int or t is float or t is bool or value is None:
+        return value
+    if t is dict:
+        return {k: _copy_field_value(v) for k, v in value.items()}
+    if t is list:
+        return [_copy_field_value(v) for v in value]
+    if t is tuple:
+        return tuple(_copy_field_value(v) for v in value)
+    if is_dataclass(value) and not isinstance(value, type):
+        return asdict(value)
+    return copy.deepcopy(value)
+
+
 @dataclass
 class Program:
     """Represents a program in the database"""
@@ -80,7 +104,8 @@ class Program:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary representation"""
-        return asdict(self)
+        values = self.__dict__
+        return {name: _copy_field_value(values[name]) for name in _PROGRAM_FIELD_NAMES}
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Program":
@@ -112,6 +137,11 @@ def from_dict(cls, data: Dict[str, Any]) -> "Program":
         return cls(**filtered_data)
 
 
+# Field order of Program, resolved once. to_dict() walks this instead of calling
+# dataclasses.fields() on every call.
+_PROGRAM_FIELD_NAMES = tuple(f.name for f in fields(Program))
+
+
 class ProgramDatabase:
     """
     Database for storing and sampling programs during evolution
@@ -121,9 +151,18 @@ class ProgramDatabase:
     It also tracks the absolute best program separately to ensure it's never lost.
     """
 
+    # Bound on _code_shape_cache. A class attribute rather than an instance one so it
+    # is available to _fast_code_diversity from inside __init__ itself.
+    _CODE_SHAPE_CACHE_SIZE = 2048
+
     def __init__(self, config: DatabaseConfig):
         self.config = config
 
+        # Bound before anything else in __init__: load() below reaches
+        # log_island_status() -> get_island_stats() -> _calculate_island_diversity()
+        # -> _fast_code_diversity(), which needs this cache.
+        self._code_shape_cache: Dict[str, Tuple[int, int, frozenset]] = {}
+
         # In-memory program storage
         self.programs: Dict[str, Program] = {}
 
@@ -2092,6 +2131,24 @@ def _calculate_island_diversity(self, programs: List[Program]) -> float:
 
         return total_diversity / max(1, comparisons)
 
+    def _code_shape(self, code: str) -> Tuple[int, int, frozenset]:
+        """
+        Length, newline count and character set of one code string, memoized.
+
+        _get_cached_diversity() compares one program against the whole reference set,
+        so the same reference strings are re-scanned once per comparison, and the
+        program's own string is re-scanned once per reference entry. Each scan is
+        O(len(code)); the derived values only depend on the string itself.
+        """
+        shape = self._code_shape_cache.get(code)
+        if shape is None:
+            shape = (len(code), code.count("\n"), frozenset(code))
+            if len(self._code_shape_cache) >= self._CODE_SHAPE_CACHE_SIZE:
+                # Same insertion-order eviction the diversity cache uses
+                del self._code_shape_cache[next(iter(self._code_shape_cache))]
+            self._code_shape_cache[code] = shape
+        return shape
+
     def _fast_code_diversity(self, code1: str, code2: str) -> float:
         """
         Fast approximation of code diversity using simple metrics
@@ -2101,18 +2158,16 @@ def _fast_code_diversity(self, code1: str, code2: str) -> float:
         if code1 == code2:
             return 0.0
 
+        len1, lines1, chars1 = self._code_shape(code1)
+        len2, lines2, chars2 = self._code_shape(code2)
+
         # Length difference (scaled to reasonable range)
-        len1, len2 = len(code1), len(code2)
         length_diff = abs(len1 - len2)
 
         # Line count difference
-        lines1 = code1.count("\n")
-        lines2 = code2.count("\n")
         line_diff = abs(lines1 - lines2)
 
         # Simple character set difference
-        chars1 = set(code1)
-        chars2 = set(code2)
         char_diff = len(chars1.symmetric_difference(chars2))
 
         # Combine metrics (scaled to match original edit distance range)
@@ -2206,9 +2261,10 @@ def _cache_diversity_value(self, code_hash: int, diversity: float) -> None:
         """Cache a diversity value with LRU eviction"""
         # Check if cache is full
         if len(self.diversity_cache) >= self.diversity_cache_size:
-            # Remove oldest entry
-            oldest_hash = min(self.diversity_cache.items(), key=lambda x: x[1]["timestamp"])[0]
-            del self.diversity_cache[oldest_hash]
+            # Remove oldest entry. Entries are inserted in increasing timestamp order
+            # and dicts preserve insertion order, so the first key is the same entry
+            # the previous min()-over-timestamps scan selected, without the O(n) scan.
+            del self.diversity_cache[next(iter(self.diversity_cache))]
 
         # Add new entry
         self.diversity_cache[code_hash] = {"value": diversity, "timestamp": time.time()}
@@ -2239,9 +2295,13 @@ def _update_feature_stats(self, feature_name: str, value: float) -> None:
         stats["max"] = max(stats["max"], value)
 
         # Keep recent values for more sophisticated scaling methods
-        stats["values"].append(value)
-        if len(stats["values"]) > 1000:  # Limit memory usage
-            stats["values"] = stats["values"][-1000:]
+        values = stats["values"]
+        values.append(value)
+        if len(values) > 1000:  # Limit memory usage
+            # The list is trimmed one element at a time, so dropping the head in place
+            # is the same window the [-1000:] slice produced, without allocating and
+            # copying a fresh 1000-element list on every call once the window is full.
+            del values[0]
 
     def _scale_feature_value(self, feature_name: str, value: float) -> float:
         """