refactor: retain refresh traversal and unpublished window documents across polls

This commit is contained in:
2026-10-23 01:20:00 +08:00
parent 175421ece3
commit 3a636a8a79
4 changed files with 256 additions and 101 deletions
+227 -101
View File
@@ -200,6 +200,23 @@ fn compile_plan_with_globals(
/// One real VM, owned only by the existing execution worker. No history replay.
/// The UI bridge shares the same managed object heap and publishes atomic frames.
struct RefreshWork {
documents: std::collections::BTreeMap<u64, RenderDocument>,
windows: std::collections::VecDeque<u64>,
current: Option<u64>,
root: Option<std::sync::Arc<crate::ui_bridge::UiNode>>,
pending: Option<Box<crate::ui_bridge::PendingLayout>>,
pass_start: bool,
pass_changed: bool,
changed: bool,
work: usize,
}
enum RefreshProgress {
Pending,
Complete(Option<RenderDocument>),
}
pub struct ReplSession {
candidate: Candidate,
bridge: ui_bridge::UiBridge,
@@ -211,6 +228,7 @@ pub struct ReplSession {
faulted: bool,
program_root: Option<CodeNode>,
documents: std::collections::BTreeMap<u64, RenderDocument>,
refresh: Option<RefreshWork>,
}
pub struct ReplResult {
pub value: String,
@@ -333,6 +351,7 @@ impl ReplSession {
faulted: false,
program_root: None,
documents: std::collections::BTreeMap::new(),
refresh: None,
})
}
pub fn execute(&mut self, source: &str, namespace: &str) -> Result<ReplResult> {
@@ -471,116 +490,200 @@ impl ReplSession {
result
}
pub fn has_pending_refresh(&self) -> bool {
self.refresh.is_some()
}
fn refresh_document(&mut self) -> Result<Option<RenderDocument>> {
let mut work = 0;
let mut changed = false;
let mut mutated_mounts = false;
let result = (|| {
loop {
if let Err(error) = self.bridge.refresh_bindings(&mut self.candidate.vm) {
self.faulted = true;
return Err(error);
}
let mut pass_changed = false;
for id in self.bridge.window_ids()? {
self.bridge.select_window(id)?;
while let Some(root) = self.bridge.prepare_frame(&mut self.candidate.vm)? {
mutated_mounts = true;
let frame = self
.bridge
.layout_frame(&mut self.candidate.vm, root.clone())?;
let mut document = RenderDocument {
windows: std::collections::BTreeMap::new(),
source: self.source.clone(),
root: Some(self.program_root.clone().unwrap_or_else(|| CodeNode {
id: format!("console-session-{}", self.id),
name: format!("Console session {}", self.id),
kind: "repl-session".into(),
start_line: 1,
end_line: self.source.lines().count(),
children: self.nodes.clone(),
})),
frame,
ui_root: root.clone(),
};
document.frame.session = self.id;
document.validate()?;
work += document.frame.mounts.len().max(1);
if work > 200_000 {
bail!(
"layout dependencies did not stabilize within the rendering work budget"
);
}
self.bridge.paint_frame(
&mut self.candidate.vm,
root.as_deref(),
&mut document.frame,
)?;
document.validate()?;
self.documents.insert(id, document);
pass_changed = true;
changed = true;
}
}
if !pass_changed {
break;
}
loop {
match self.poll_refresh(false)? {
RefreshProgress::Pending => std::thread::yield_now(),
RefreshProgress::Complete(document) => return Ok(document),
}
self.bridge.finish_closed(&mut self.candidate.vm)?;
let ids = self.bridge.window_ids()?;
self.documents.retain(|id, _| ids.contains(id));
if !changed {
return Ok(None);
}
let mut main = self
.documents
.get(&crate::window::MAIN_WINDOW)
.cloned()
.unwrap_or_else(|| RenderDocument {
source: self.source.clone(),
frame: crate::document::Frame {
session: self.id,
..crate::document::Frame::default()
},
..RenderDocument::default()
});
main.source = self.source.clone();
main.root = self
.documents
.values()
.find(|document| document.source == self.source)
.and_then(|document| document.root.clone())
.or(main.root);
main.windows = self
.documents
.iter()
.filter(|(id, _)| **id != crate::window::MAIN_WINDOW)
.map(|(id, document)| (*id, document.clone()))
.collect();
main.validate()?;
Ok(Some(main))
})();
self.bridge.select_window(crate::window::MAIN_WINDOW)?;
if result.is_err() && mutated_mounts {
self.faulted = true;
}
result
}
fn poll_refresh(&mut self, record_yield: bool) -> Result<RefreshProgress> {
let mut work = self.refresh.take().unwrap_or_else(|| RefreshWork {
documents: self.documents.clone(),
windows: Default::default(),
current: None,
root: None,
pending: None,
pass_start: true,
pass_changed: false,
changed: false,
work: 0,
});
let result = (|| {
if self.step_refresh(&mut work)? {
return Ok(true);
}
if record_yield {
self.bridge.note_refresh_yield()?;
}
Ok(false)
})();
match result {
Ok(false) => {
self.refresh = Some(work);
Ok(RefreshProgress::Pending)
}
Ok(true) => {
let result = self.finish_refresh(work);
self.bridge.select_window(crate::window::MAIN_WINDOW)?;
if result.is_err() {
self.faulted = true;
}
result.map(RefreshProgress::Complete)
}
Err(error) => {
self.faulted = true;
if let Some(pending) = work.pending.take() {
self.bridge
.abort_layout_frame(&mut self.candidate.vm, *pending)?;
}
self.bridge.select_window(crate::window::MAIN_WINDOW)?;
Err(error)
}
}
}
fn step_refresh(&mut self, work: &mut RefreshWork) -> Result<bool> {
if work.pass_start {
self.bridge.refresh_bindings(&mut self.candidate.vm)?;
work.windows = self.bridge.window_ids()?.into();
work.current = None;
work.pass_changed = false;
work.pass_start = false;
return Ok(false);
}
let Some(id) = work.current else {
if let Some(id) = work.windows.pop_front() {
work.current = Some(id);
return Ok(false);
}
if work.pass_changed {
work.pass_start = true;
return Ok(false);
}
return Ok(true);
};
self.bridge.select_window(id)?;
let progress = if let Some(pending) = work.pending.take() {
self.bridge
.resume_layout_frame(&mut self.candidate.vm, *pending)?
} else if let Some(root) = self.bridge.prepare_frame(&mut self.candidate.vm)? {
work.root = root.clone();
self.bridge
.begin_layout_frame(&mut self.candidate.vm, root)?
} else {
work.current = None;
return Ok(false);
};
let frame = match progress {
crate::ui_bridge::LayoutProgress::Pending(pending) => {
work.pending = Some(pending);
return Ok(false);
}
crate::ui_bridge::LayoutProgress::Complete(frame) => *frame,
};
let mut document = RenderDocument {
windows: Default::default(),
source: self.source.clone(),
root: Some(self.program_root.clone().unwrap_or_else(|| CodeNode {
id: format!("console-session-{}", self.id),
name: format!("Console session {}", self.id),
kind: "repl-session".into(),
start_line: 1,
end_line: self.source.lines().count(),
children: self.nodes.clone(),
})),
frame,
ui_root: work.root.take(),
};
document.frame.session = self.id;
document.validate()?;
work.work += document.frame.mounts.len().max(1);
if work.work > 200_000 {
bail!("layout dependencies did not stabilize within the rendering work budget");
}
self.bridge.paint_frame(
&mut self.candidate.vm,
document.ui_root.as_deref(),
&mut document.frame,
)?;
document.validate()?;
work.documents.insert(id, document);
work.pass_changed = true;
work.changed = true;
Ok(false)
}
fn finish_refresh(&mut self, mut work: RefreshWork) -> Result<Option<RenderDocument>> {
self.bridge.finish_closed(&mut self.candidate.vm)?;
let ids = self.bridge.window_ids()?;
work.documents.retain(|id, _| ids.contains(id));
if !work.changed {
self.documents = work.documents;
return Ok(None);
}
let mut main = work
.documents
.get(&crate::window::MAIN_WINDOW)
.cloned()
.unwrap_or_else(|| RenderDocument {
source: self.source.clone(),
frame: crate::document::Frame {
session: self.id,
..Default::default()
},
..Default::default()
});
main.source = self.source.clone();
main.root = work
.documents
.values()
.find(|document| document.source == self.source)
.and_then(|document| document.root.clone())
.or(main.root);
main.windows = work
.documents
.iter()
.filter(|(id, _)| **id != crate::window::MAIN_WINDOW)
.map(|(id, document)| (*id, document.clone()))
.collect();
main.validate()?;
self.documents = work.documents;
Ok(Some(main))
}
pub fn resize_windows(
&mut self,
viewports: &std::collections::BTreeMap<u64, crate::layout::Size>,
) -> Result<Option<RenderDocument>> {
self.resize_windows_incremental(viewports, true)
}
pub fn resize_windows_incremental(
&mut self,
viewports: &std::collections::BTreeMap<u64, crate::layout::Size>,
drain: bool,
) -> Result<Option<RenderDocument>> {
if self.faulted {
bail!("runtime stopped after a callback or rendering failure");
}
let previous = if self.has_pending_refresh() {
if drain {
let result = self.refresh_document();
self.finish_refresh_update(result)?
} else {
return self.advance_idle_refresh();
}
} else {
None
};
let ids = self.bridge.window_ids()?;
if ids.len() == 1
&& let Some(viewport) = viewports.get(&crate::window::MAIN_WINDOW)
{
self.bridge.select_window(crate::window::MAIN_WINDOW)?;
return self.resize(Some(*viewport));
}
let mut changed = false;
for (id, viewport) in viewports {
if ids.contains(id) {
@@ -592,15 +695,38 @@ impl ReplSession {
}
self.bridge.select_window(crate::window::MAIN_WINDOW)?;
if !changed {
return Ok(None);
return Ok(previous);
}
let result = self.refresh_document();
if drain {
let result = self
.refresh_document()
.map(|document| document.or(previous));
self.finish_refresh_update(result)
} else {
self.advance_idle_refresh()
}
}
fn advance_idle_refresh(&mut self) -> Result<Option<RenderDocument>> {
let result = self.poll_refresh(true).map(|progress| match progress {
RefreshProgress::Pending => None,
RefreshProgress::Complete(document) => document,
});
self.finish_refresh_update(result)
}
fn finish_refresh_update(
&mut self,
result: Result<Option<RenderDocument>>,
) -> Result<Option<RenderDocument>> {
if result.is_err() {
self.take_window_commands()?;
self.bridge.discard_pending(&mut self.candidate.vm)?;
}
self.bridge
.reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?;
if !self.has_pending_refresh() {
self.bridge
.reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?;
}
result
}