From e1747ca560402d06c2c9b9cab350a1935fdb0800 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Fri, 14 Aug 2026 12:11:54 +0800 Subject: [PATCH] =?UTF-8?q?perf:=20ASCII=20=E5=8D=95=E5=AD=97=E7=AC=A6?= =?UTF-8?q?=E7=BC=93=E5=AD=98=20+=20=E5=AD=97=E7=AC=A6=E4=B8=B2=E8=BF=AD?= =?UTF-8?q?=E4=BB=A3=E5=99=A8=E6=B8=B8=E6=A0=87=E6=94=B6=E5=B0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_builtins/src/iterator.rs | 17 +++--- crates/oxide_builtins/src/string.rs | 54 +++++++++++++++---- crates/oxide_kernel/src/string_forge.rs | 52 +++++++++++++++++- crates/oxide_runtime_api/src/lib.rs | 13 +++++ crates/oxide_vm/src/vm_dispatch_misc.rs | 30 ++++++++--- .../oxide_vm/tests/builtins_iterator_tests.rs | 37 +++++++++++++ .../oxide_vm/tests/builtins_string_tests.rs | 51 ++++++++++++++++++ 7 files changed, 229 insertions(+), 25 deletions(-) diff --git a/crates/oxide_builtins/src/iterator.rs b/crates/oxide_builtins/src/iterator.rs index 24355e8..1876046 100644 --- a/crates/oxide_builtins/src/iterator.rs +++ b/crates/oxide_builtins/src/iterator.rs @@ -7,8 +7,6 @@ use oxide_runtime_api::{to_object, NativeResult, VmHost}; const INNER_PROP: &str = "__inner__"; const INDEX_PROP: &str = "__index__"; -/// 字符串迭代的字节游标（`next` 增量推进的当前位置），避免每步整串复制 + 从头重扫。 -const BYTEOFF_PROP: &str = "__byteoff__"; /// 占位构造函数：`Iterator` 不是构造函数，任何调用都抛 TypeError。 pub fn iterator_constructor(vm: &mut H, _args: &[u8]) -> NativeResult { @@ -305,16 +303,19 @@ fn next_array_like( } if inner.is_string() { - let index = current_index(vm, wrapper, index_si); - let byteoff_si = vm.kernel_core().perm_interner().intern(BYTEOFF_PROP).0; - let byteoff = current_index(vm, wrapper, byteoff_si); + // index 槽在字符串分支存字节游标（每步推进一个 char 的 UTF-8 宽度）而非 + // 元素序号：该槽只被 next 内部读写、无外部消费者，包装器创建后类型固定 + // 不跨类型复用，故可安全借用语义（字符串=字节偏移）。 + let byteoff = current_index(vm, wrapper, index_si); // 源串裸指针借用压缩到单个表达式：ch 是 Copy 的 char，不携带借用， // 之后对 VM 状态的可变访问不再与源串借用共存。 let ch = unsafe { &*inner.as_string_ptr() }.as_str()[byteoff..].chars().next(); if let Some(ch) = ch { - vm.set_or_create_prop_value(wrapper, byteoff_si, JsValue::int((byteoff + ch.len_utf8()) as i32)); - vm.set_or_create_prop_value(wrapper, index_si, JsValue::int((index + 1) as i32)); - let value = vm.new_string(&ch.to_string()); + vm.set_or_create_prop_value(wrapper, index_si, JsValue::int((byteoff + ch.len_utf8()) as i32)); + let value = match vm.single_char(ch) { + Some(v) => v, + None => vm.new_string(&ch.to_string()), + }; return Ok(Some(make_iter_result(vm, value, false))); } return Ok(Some(make_iter_result(vm, JsValue::undefined(), true))); diff --git a/crates/oxide_builtins/src/string.rs b/crates/oxide_builtins/src/string.rs index 7085ea3..00363ca 100644 --- a/crates/oxide_builtins/src/string.rs +++ b/crates/oxide_builtins/src/string.rs @@ -201,6 +201,23 @@ pub(crate) fn make_string_array(vm: &mut H, parts: Vec) -> Js JsValue::from_js_object(arr) } +/// 以已构造的字符串值构建字符串数组（元素零拷贝落地），供逐字符产出路径 +/// （空分隔 split）复用，跳过 `Vec` 中间层。 +pub(crate) fn make_string_array_values(vm: &mut H, parts: Vec) -> JsValue { + let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; + let n = parts.len(); + let arr = + vm.epoch() + .alloc(JsObject::new_array(EMPTY_SHAPE_ID, JsValue::from_js_object(proto), n, vm.epoch().bump())); + unsafe { + for (i, sv) in parts.into_iter().enumerate() { + (*arr).set_prop_at(i, sv); + } + (*arr).set_prop_count(n); + } + JsValue::from_js_object(arr) +} + /// 取参数字符串内容：原始字符串零拷贝借用，其余经完整 ToString（对象 ToPrimitive）。 /// 返回借用绑定本次 `&mut` 借用；需与 `this_string` 借用并存时先 `into_owned` 落地。 fn as_string<'a, H: VmHost>(vm: &'a mut H, val: JsValue) -> Cow<'a, str> { @@ -500,14 +517,24 @@ pub fn string_char_at(vm: &mut H, args: &[u8]) -> NativeResult { if s.is_empty() { return NativeResult::Ok(vm.new_string("")); } - let first = take_chars(&s, 1); - return NativeResult::Ok(vm.new_string(&first)); + let first = s.chars().next().unwrap(); + // ASCII 走单字符缓存零分配，其余回落普通创建（借用已随 char 提取结束）。 + return match vm.single_char(first) { + Some(v) => NativeResult::Ok(v), + None => NativeResult::Ok(vm.new_string(&first.to_string())), + }; } if idx < 0 || idx as usize >= char_len(&s) { return NativeResult::Ok(vm.new_string("")); } - let ch = s.chars().nth(idx as usize).map(|c| c.to_string()).unwrap_or_default(); - NativeResult::Ok(vm.new_string(&ch)) + let ch = s.chars().nth(idx as usize); + match ch { + Some(c) => match vm.single_char(c) { + Some(v) => NativeResult::Ok(v), + None => NativeResult::Ok(vm.new_string(&c.to_string())), + }, + None => NativeResult::Ok(vm.new_string("")), + } } /// `String.prototype.charCodeAt(index)`：返回指定位置字符的 UTF-16 code unit；越界返回 NaN。 @@ -950,11 +977,20 @@ pub fn string_split(vm: &mut H, args: &[u8]) -> NativeResult { } // 无原生正则的类正则对象回退到字符串路径。 } - let parts: Vec = if sep.is_empty() { - s.chars().map(|c| c.to_string()).take(limit).collect() - } else { - s.split(&sep).map(|p| p.to_string()).take(limit).collect() - }; + if sep.is_empty() { + // 两段式：先借 this 收集字符（Copy），借用结束后再逐字符产出—— + // ASCII 走单字符缓存零分配，其余回落普通创建。 + let chars: Vec = s.chars().take(limit).collect(); + let mut values = Vec::with_capacity(chars.len()); + for c in chars { + values.push(match vm.single_char(c) { + Some(v) => v, + None => vm.new_string(&c.to_string()), + }); + } + return NativeResult::Ok(make_string_array_values(vm, values)); + } + let parts: Vec = s.split(&sep).map(|p| p.to_string()).take(limit).collect(); NativeResult::Ok(make_string_array(vm, parts)) } diff --git a/crates/oxide_kernel/src/string_forge.rs b/crates/oxide_kernel/src/string_forge.rs index 90c30f2..4979640 100644 --- a/crates/oxide_kernel/src/string_forge.rs +++ b/crates/oxide_kernel/src/string_forge.rs @@ -1,5 +1,5 @@ use std::hash::{Hash, Hasher}; -use std::sync::RwLock; +use std::sync::{OnceLock, RwLock}; use dashmap::DashMap; use oxide_types::object::JsString; @@ -142,6 +142,39 @@ impl Default for PermInterner { } } +/// 指向永久 `JsString` 的指针包装，供静态表存储。`JsString` 内容线程安全 +/// （`String` + `AtomicU32`）且永久存活、只读共享，裸指针跨线程传递安全。 +#[derive(Clone, Copy)] +#[repr(transparent)] +struct StringPtr(*const JsString); +unsafe impl Send for StringPtr {} +unsafe impl Sync for StringPtr {} + +/// ASCII 单字符永久 `JsString` 指针表：以字节值（0..=127）为下标， +/// 首用惰性物化 `Box::into_raw` 永久泄漏，之后恒复用同一地址。 +/// 泄漏面严格有界：≤128 条目 × 单字符内容（≈8KB），进程生命周期内不释放。 +static SINGLE_CHAR_TABLE: [OnceLock; 128] = [const { OnceLock::new() }; 128]; + +/// 取 ASCII 单字符的永久 `JsString` 指针，惰性物化一次后恒返回同一地址。 +/// 供迭代器/charAt/空分隔 split/字符串展开等高频字符产出路径零分配复用； +/// 并发首用竞态下仍保证全局唯一指针（后者回收本线程副本）。 +pub fn single_char_ptr(ch: u8) -> *const JsString { + let slot = &SINGLE_CHAR_TABLE[ch as usize]; + if let Some(ptr) = slot.get() { + return ptr.0; + } + let ptr = Box::into_raw(Box::new(JsString::new((ch as char).to_string()))); + match slot.set(StringPtr(ptr)) { + Ok(()) => ptr, + Err(existing) => { + // 并发首用竞态：另一线程已物化，本线程指针尚未暴露给调用方，恰好释放一次。 + // SAFETY: ptr 来自本线程的 Box::into_raw，无任何外部引用。 + unsafe { drop(Box::from_raw(ptr)) }; + existing.0 + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -206,4 +239,21 @@ mod tests { // 二次调用返回同一稳定指针（仅物化一次）。 assert_eq!(interner.string_ptr(id), ptr); } + + #[test] + fn single_char_ptr_idempotent() { + let a = single_char_ptr(b'a'); + assert_eq!(unsafe { (*a).as_str() }, "a"); + // 二次调用返回同一稳定指针（仅物化一次）。 + assert_eq!(single_char_ptr(b'a'), a); + } + + #[test] + fn single_char_table_full_ascii() { + // 全表 128 条目均可物化且内容为对应的单字符文本。 + for b in 0u8..=127 { + let ptr = single_char_ptr(b); + assert_eq!(unsafe { (*ptr).as_str() }, (b as char).to_string()); + } + } } diff --git a/crates/oxide_runtime_api/src/lib.rs b/crates/oxide_runtime_api/src/lib.rs index b700e77..1124ebb 100644 --- a/crates/oxide_runtime_api/src/lib.rs +++ b/crates/oxide_runtime_api/src/lib.rs @@ -77,6 +77,19 @@ pub trait VmHost { fn new_string(&mut self, s: &str) -> JsValue; /// move 接收 `String` 创建会话字符串，避免一次整串克隆。 fn new_string_owned(&mut self, s: String) -> JsValue; + /// 取 ASCII 单字符的永久字符串值：命中返回共享 perm 串（零分配、可指针 + /// 短路比较），非 ASCII 返回 `None` 由调用方回落普通字符串创建。 + /// + /// # 注意事项 + /// `&self` 可借用期调用；`None` 回落 `new_string` 是 `&mut` 路径，须先结束 + /// 本次 `&self` 借用（返回值即时消费即可）。 + fn single_char(&self, ch: char) -> Option { + if ch.is_ascii() { + Some(JsValue::string(oxide_kernel::string_forge::single_char_ptr(ch as u8))) + } else { + None + } + } /// 借出字符串值的文本内容，生命周期绑定到 `&self` 借用。 /// /// perm 字符串由内核持有、永不释放；session 字符串只在 `&mut self` 路径 diff --git a/crates/oxide_vm/src/vm_dispatch_misc.rs b/crates/oxide_vm/src/vm_dispatch_misc.rs index 241d92c..d4dc9fb 100644 --- a/crates/oxide_vm/src/vm_dispatch_misc.rs +++ b/crates/oxide_vm/src/vm_dispatch_misc.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use crate::native::NativeFn; use crate::vm::{native_fn_ptr_to_fn, CallFrame, ForInIter, FrameContinuation, Vm, MAX_PROTO_CHAIN_DEPTH}; use crate::vm_trace; -use oxide_runtime_api::{to_boolean, to_string_full, NativeResult}; +use oxide_runtime_api::{to_boolean, to_string_full, NativeResult, VmHost}; use oxide_types::object::{JsObject, PropAttributes}; use oxide_types::private_key::{int_key_value, is_int_key, is_private_name_key, is_symbol_key, make_int_key}; use oxide_types::value::JsValue; @@ -738,9 +738,14 @@ impl Vm { if src.is_string() { let code_units: Vec = unsafe { (*src.as_string_ptr()).data.encode_utf16().collect() }; for (i, unit) in code_units.iter().enumerate() { - let s = char::from_u32(*unit as u32).map(|c| c.to_string()).unwrap_or_default(); let si = make_int_key(i as u32); - let ch_val = self.new_string(&s); + let ch_val = match char::from_u32(*unit as u32) { + Some(c) => match self.single_char(c) { + Some(v) => v, + None => self.new_string(&c.to_string()), + }, + None => self.new_string(""), + }; let rest = unsafe { &mut *rest_ptr }; self.set_or_create_prop_value(rest, si, ch_val); } @@ -792,9 +797,15 @@ impl Vm { let s = unsafe { (*raw.as_string_ptr()).data.clone() }; let code_units: Vec = s.encode_utf16().collect(); for (i, unit) in code_units.iter().enumerate() { - let ch = char::from_u32(*unit as u32).map(|c| c.to_string()).unwrap_or_default(); let si = make_int_key(i as u32); - assignments.push((si, self.new_string(&ch))); + let ch_val = match char::from_u32(*unit as u32) { + Some(c) => match self.single_char(c) { + Some(v) => v, + None => self.new_string(&c.to_string()), + }, + None => self.new_string(""), + }; + assignments.push((si, ch_val)); } } @@ -887,9 +898,14 @@ impl Vm { let target = unsafe { &mut *target_val.as_js_object_ptr() }; let code_units: Vec = unsafe { (*src.as_string_ptr()).data.encode_utf16().collect() }; for (i, unit) in code_units.iter().enumerate() { - let s = char::from_u32(*unit as u32).map(|c| c.to_string()).unwrap_or_default(); let si = make_int_key(i as u32); - let ch_val = self.new_string(&s); + let ch_val = match char::from_u32(*unit as u32) { + Some(c) => match self.single_char(c) { + Some(v) => v, + None => self.new_string(&c.to_string()), + }, + None => self.new_string(""), + }; self.set_or_create_prop_value(target, si, ch_val); } return Ok(()); diff --git a/crates/oxide_vm/tests/builtins_iterator_tests.rs b/crates/oxide_vm/tests/builtins_iterator_tests.rs index 9563c21..9ea9b5a 100644 --- a/crates/oxide_vm/tests/builtins_iterator_tests.rs +++ b/crates/oxide_vm/tests/builtins_iterator_tests.rs @@ -58,3 +58,40 @@ fn new_iterator_throws_type_error() { let result = eval(&mut vm, "try { new Iterator() } catch (e) { e instanceof TypeError }").unwrap(); assert!(result.as_bool()); } + +#[test] +fn iterator_from_string_full_sequence() { + // 手动 next 逐字符取完全部 ASCII 字符后 done（游标推进路径）。 + let mut vm = Vm::new(); + let result = eval( + &mut vm, + "var it = Iterator.from('ab'); \ + var r = []; var x; while (!(x = it.next()).done) r.push(x.value); \ + r.join('')", + ) + .unwrap(); + assert_eq!(to_str(&vm, result), "ab"); +} + +#[test] +fn iterator_from_string_astral_scalar() { + // 字符串迭代按 Unicode 标量推进：astral 字符整体产出（标量语义未动）。 + let mut vm = Vm::new(); + let result = eval(&mut vm, "var it = Iterator.from('\\u{1F600}'); it.next().value").unwrap(); + assert_eq!(to_str(&vm, result), "\u{1F600}"); +} + +#[test] +fn iterator_from_string_empty_done() { + let mut vm = Vm::new(); + let result = eval(&mut vm, "Iterator.from('').next().done").unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn for_of_string_chars() { + // for-of 字符串循环产出逐字符（走字节游标 + 单字符缓存）。 + let mut vm = Vm::new(); + let result = eval(&mut vm, "var out = []; for (const c of 'abc') out.push(c); out.join('')").unwrap(); + assert_eq!(to_str(&vm, result), "abc"); +} diff --git a/crates/oxide_vm/tests/builtins_string_tests.rs b/crates/oxide_vm/tests/builtins_string_tests.rs index 6390e91..e5e0b35 100644 --- a/crates/oxide_vm/tests/builtins_string_tests.rs +++ b/crates/oxide_vm/tests/builtins_string_tests.rs @@ -651,3 +651,54 @@ fn string_slice_astral_character_indices() { let s = eval(&mut vm, "'\\u{1F600}'.padStart(3, 'x')").unwrap(); assert_eq!(to_str(&vm, s), "xx\u{1F600}"); } + +#[test] +fn string_char_at_ascii_and_astral() { + // charAt 产出：ASCII 走单字符缓存，astral 按标量整体返回，越界空串， + // 缺省参数取首字符。 + let mut vm = Vm::new(); + let s = eval(&mut vm, "'abc'.charAt(1)").unwrap(); + assert_eq!(to_str(&vm, s), "b"); + let s = eval(&mut vm, "'\\u{1F600}ab'.charAt(0)").unwrap(); + assert_eq!(to_str(&vm, s), "\u{1F600}"); + let s = eval(&mut vm, "'ab'.charAt(5)").unwrap(); + assert_eq!(to_str(&vm, s), ""); + let s = eval(&mut vm, "'xy'.charAt()").unwrap(); + assert_eq!(to_str(&vm, s), "x"); +} + +#[test] +fn string_char_at_eq_perm_string() { + // charAt 产出与字面量比较：内容相等（缓存串与字面量 perm 串）。 + let mut vm = Vm::new(); + let result = eval(&mut vm, "'abc'.charAt(1) === 'b'").unwrap(); + assert!(result.as_bool()); +} + +#[test] +fn string_split_empty_separator_chars() { + // 空分隔 split 逐字符产出：ASCII 走单字符缓存，混合 astral 按标量切分。 + let mut vm = Vm::new(); + let s = eval(&mut vm, "'abc'.split('').join('-')").unwrap(); + assert_eq!(to_str(&vm, s), "a-b-c"); + let result = eval(&mut vm, "'\\u{1F600}a'.split('').length").unwrap(); + assert_eq!(result.as_int(), 2); + let result = eval(&mut vm, "'\\u{1F600}a'.split('')[1]").unwrap(); + assert_eq!(to_str(&vm, result), "a"); +} + +#[test] +fn string_spread_object_chars() { + // 对象展开字符串源：索引字符为可枚举自有属性。 + let mut vm = Vm::new(); + let result = eval(&mut vm, "const o = {...'ab'}; o['0'] + o['1']").unwrap(); + assert_eq!(to_str(&vm, result), "ab"); +} + +#[test] +fn string_rest_destructure_chars() { + // rest 解构字符串源：索引字符收集到 rest 对象。 + let mut vm = Vm::new(); + let result = eval(&mut vm, "const {...r} = 'ab'; r['0'] + r['1']").unwrap(); + assert_eq!(to_str(&vm, result), "ab"); +}