perf: 池构造时同步预热 min_size 个 Vm 并删除三个死配置旗标

crates/oxide_kernel/src/kernel/config.rs

@@ -1,10 +1,10 @@
 //! kernel 运行配置：VM 池规模、步数/调用深度/单 run 分配上限、session GC 阈值、
-//! perm interner 重建阈值、日志级别与内置对象预热开关（三预设 minimal/standard/full）。
+//! perm interner 重建阈值、日志级别（三预设 minimal/standard/full）。
 
 use oxide_log::{Level, SUBSYSTEM_COUNT};
 
 /// kernel 运行配置：VM 池规模、步数/调用深度/单 run 分配上限、session GC 阈值、
-/// perm interner 重建阈值、日志级别与内置对象预热开关。由三个预设构造器
+/// perm interner 重建阈值、日志级别。由三个预设构造器
 /// （[`KernelConfig::minimal`] / [`KernelConfig::standard`] / [`KernelConfig::full`]）
 /// 或默认值创建。
 #[derive(Clone)]
@@ -26,13 +26,10 @@ pub struct KernelConfig {
     pub session_gc_threshold: usize,
     pub max_cached_modules: usize,
     pub log_levels: [Level; SUBSYSTEM_COUNT],
-    pub warmup_builtin_shapes: bool,
-    pub warmup_builtin_code: bool,
-    pub warmup_builtin_ic: bool,
 }
 
 impl KernelConfig {
-    /// 最小配置：小 VM 池、关闭 code/IC 预热，适合嵌入式或单次执行场景。
+    /// 最小配置：小 VM 池，适合嵌入式或单次执行场景。
     pub fn minimal() -> Self {
         Self {
             min_pool_size: 4,
@@ -44,13 +41,10 @@ impl KernelConfig {
             session_gc_threshold: 33_554_432,
             max_cached_modules: 512,
             log_levels: [Level::Off; SUBSYSTEM_COUNT],
-            warmup_builtin_shapes: true,
-            warmup_builtin_code: false,
-            warmup_builtin_ic: false,
         }
     }
 
-    /// 标准配置：默认 VM 池大小，开启内置对象 code 预热。
+    /// 标准配置：默认 VM 池大小。
     pub fn standard() -> Self {
         Self {
             min_pool_size: 8,
@@ -62,13 +56,10 @@ impl KernelConfig {
             session_gc_threshold: 33_554_432,
             max_cached_modules: 512,
             log_levels: [Level::Off; SUBSYSTEM_COUNT],
-            warmup_builtin_shapes: true,
-            warmup_builtin_code: true,
-            warmup_builtin_ic: false,
         }
     }
 
-    /// 全量配置：无上限 VM 池，开启 shapes/code/IC 全量预热，为性能场景服务。
+    /// 全量配置：无上限 VM 池，为性能场景服务。
     pub fn full() -> Self {
         Self {
             min_pool_size: 16,
@@ -80,9 +71,6 @@ impl KernelConfig {
             session_gc_threshold: 33_554_432,
             max_cached_modules: 512,
             log_levels: [Level::Off; SUBSYSTEM_COUNT],
-            warmup_builtin_shapes: true,
-            warmup_builtin_code: true,
-            warmup_builtin_ic: true,
         }
     }
 

crates/oxide_kernel/tests/kernel_tests.rs

@@ -45,8 +45,6 @@ fn test_kernel_config_presets() {
     assert_eq!(KernelConfig::standard().max_steps, None);
     assert_eq!(KernelConfig::full().max_steps, None);
     assert_eq!(KernelConfig::minimal().log_levels, [Level::Off; SUBSYSTEM_COUNT]);
-    assert!(!KernelConfig::minimal().warmup_builtin_ic);
-    assert!(KernelConfig::full().warmup_builtin_ic);
     assert_eq!(KernelConfig::full().max_pool_size, None);
 }
 

crates/oxide_vm/src/vm_pool.rs

@@ -34,17 +34,26 @@ pub struct VmGuard {
 }
 
 impl VmPool {
-    /// 创建空池。`min_size` 当前仅作预热预留（未使用），`max_size` 为池上限，`None` 表示不限。
-    pub fn new(kernel_core: Arc<KernelCore>, _min_size: usize, max_size: Option<usize>) -> Arc<Self> {
-        Arc::new(Self {
-            kernel_core,
+    /// 创建 VM 池并同步预热 `min_size` 个 Vm（数量受 `max_size` 钳制），
+    /// 首次 `spawn` 直接命中池。`max_size` 为池上限，`None` 表示不限。
+    pub fn new(kernel_core: Arc<KernelCore>, min_size: usize, max_size: Option<usize>) -> Arc<Self> {
+        let warm = min_size.min(max_size.unwrap_or(min_size));
+        let pool = Arc::new(Self {
+            kernel_core: Arc::clone(&kernel_core),
             inner: Mutex::new(VmPoolInner {
                 available: Vec::new(),
                 total_count: 0,
             }),
             condvar: Condvar::new(),
             max_size,
-        })
+        });
+        let mut inner = pool.inner.lock().unwrap();
+        for _ in 0..warm {
+            inner.available.push(Self::new_vm(&kernel_core));
+            inner.total_count += 1;
+        }
+        drop(inner);
+        pool
     }
 
     fn new_vm(core: &Arc<KernelCore>) -> Vm {
@@ -173,4 +182,32 @@ mod tests {
         drop(g1);
         drop(g2);
     }
+
+    #[test]
+    fn test_pool_warms_min_size_on_new() {
+        let kernel = test_kernel();
+        let pool = VmPool::new(kernel, 2, None);
+        {
+            let inner = pool.inner.lock().unwrap();
+            assert_eq!(inner.available.len(), 2);
+            assert_eq!(inner.total_count, 2);
+        }
+        let g1 = pool.spawn();
+        let g2 = pool.spawn();
+        {
+            let inner = pool.inner.lock().unwrap();
+            assert_eq!(inner.total_count, 2);
+        }
+        drop(g1);
+        drop(g2);
+    }
+
+    #[test]
+    fn test_pool_warmup_clamped_by_max_size() {
+        let kernel = test_kernel();
+        let pool = VmPool::new(kernel, 2, Some(1));
+        let inner = pool.inner.lock().unwrap();
+        assert_eq!(inner.available.len(), 1);
+        assert_eq!(inner.total_count, 1);
+    }
 }