urbit/ares
1
1
Fork 0
mirror of https://github.com/urbit/ares.git synced 2024-11-23 09:06:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Fixup comment explaining scry failure behaviour

Browse Source
This commit is contained in:
Alex Shelkovnykov 2023-10-27 06:21:35 +01:00
parent 096208a612
commit 9499b00590
1 changed files with 13 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
rust/ares/src/jets/nock.rs
View File

@ -51,18 +51,19 @@ pub fn jet_mink(context: &mut Context, subject: Noun) -> Result {
Err(error) => match error {
Error::NonDeterministic(_) => Err(JetErr::Fail(error)),
Error::ScryCrashed(trace) => {
// When we enter a +mink call, we record what the scry handler stack looked like on
// entry. Each scry pulls the scry handler off the top of the scry handler stack and
// and calls interpret() with the remainder of the scry handler stack. When a scry
// succeeds, it replaces the scry handler it used at the top of the stack. However,
// it never does so when it fails. Therefore, we can tell which particular
// virtualization instance failed if the scry handler stack at the time of failure
// is identical to the scry handler stack on entry to the +mink call. Therefore,
// when a virtual nock call returns ScryCrashed, mink compares the root of the scry
// handler stack currently in the context object with the one that was on the stack
// when the mink call was initiated. If they match, it's this mink call that crashed
// so convert the Error::ScryCrashed into a Error::Deterministic. Otherwise, pass
// the Error::ScryCrashed up to the senior virtualizer.
// When we enter a +mink call, we record the state of the scry handler stack at the
// time (i.e. the Noun representing (list scry)). Each scry will pop the head off of
// this scry handler stack and calls interpret(), using the rest of the scry handler
// stack in the event that it scries again recursively. When a scry succeeds, it
// replaces the scry handler that it used by pushing it back onto the top of the
// scry handler stack. However, it never does so when it fails. Therefore, we can
// tell which particular virtualization instance failed by comparing the scry
// handler stack at the time of failure (i.e. the scry handler stack in the context
// after a failed scry) with the scry handler stack at the time of the virtualization
// call. Thus, whenever a virtualized interpret() call fails with a
// Error::ScryCrashed, jet_mink() compares the two scry handler stack Nouns> If they
// are identical, jet_mink() bails with Error::Deterministic. Otherwise, it forwards
// the Error::ScryCrashed to the senior virtualization call.
if unsafe { context.scry_stack.raw_equals(old_scry_stack) } {
Err(JetErr::Fail(Error::Deterministic(trace)))
} else {