feat: optimized async-runtime (replace for gstd)

benchmarks/bench_data.json

@@ -1,33 +1,33 @@
 {
   "compute": {
-    "median": 465525077223
+    "median": 465525097695
   },
   "alloc": {
-    "0": 599843943,
-    "12": 603255248,
-    "143": 763104169,
-    "986": 865787429,
-    "10945": 2216328240,
-    "46367": 6545787850,
-    "121392": 17172248387,
-    "317810": 43909564540
+    "0": 599863562,
+    "12": 603274867,
+    "143": 763123788,
+    "986": 865807048,
+    "10945": 2216347859,
+    "46367": 6545807469,
+    "121392": 17172268006,
+    "317810": 43909584159
   },
   "counter": {
-    "async_call": 865267022,
-    "sync_call": 695201799
+    "async_call": 817171163,
+    "sync_call": 653756647
   },
   "cross_program": {
-    "median": 2391505600
+    "median": 2198136314
   },
   "redirect": {
-    "median": 3464158516
+    "median": 3170024744
   },
   "message_stack": {
-    "0": 792932822,
-    "1": 3752847200,
-    "5": 15633706718,
-    "10": 29340040097,
-    "20": 65942391269
+    "0": 696547455,
+    "1": 3357401971,
+    "5": 14035799870,
+    "10": 26225131218,
+    "20": 51911611286
   },
   "noop_baseline": {
     "median": 363446797

docs/syscall-mapping-spec.md

@@ -46,6 +46,7 @@ See `rs/src/types.rs`.
 | `Syscall::exit(inheritor_id)` | `!` | `gcore::exec::exit(inheritor_id)` |  |
 | `Syscall::panic(data)` | `!` | `gcore::ext::panic(data)` |  |
 | `Syscall::read_bytes()` | `Result<Vec<u8>, gcore::errors::Error>` | allocate `vec![0u8; gcore::msg::size()]`, then `gcore::msg::read(result.as_mut())` |  |
+| `Syscall::wake(message_id)` | `Result<(), gcore::errors::Error>` | `gcore::exec::wake(message_id)` |  |
 | `Syscall::system_reserve_gas(amount)` | `Result<(), gcore::errors::Error>` | `gcore::exec::system_reserve_gas(amount)` | only when `ethexe` is disabled |
 
 ## Behavioral Notes
@@ -58,7 +59,7 @@ The `message_*`, `reply_*`, and `signal_*` methods are wrappers over `gcore::msg
 
 ### Execution Context
 
-The `program_id`, `block_height`, `block_timestamp`, `value_available`, `gas_available`, `env_vars`, `exit`, and `system_reserve_gas` methods are wrappers over `gcore::exec::*` accessors and control flow.
+The `program_id`, `block_height`, `block_timestamp`, `value_available`, `gas_available`, `env_vars`, `exit`, `wake`, and `system_reserve_gas` methods are wrappers over `gcore::exec::*` accessors and control flow.
 
 ### Panic Surface
 
@@ -75,6 +76,7 @@ On non-`wasm32` targets with feature `std`:
 - `env_vars()` returns a constructed `gcore::EnvVars` value rather than delegating to `gcore::exec::env_vars()`.
 - `exit()` and `panic()` call Rust `panic!` with diagnostic text instead of delegating to runtime syscalls.
 - `read_bytes()` reads from thread-local mock state.
+- `wake()` is a no-op that returns `Ok(())` (it takes a `MessageId` argument, so it is a manual mock rather than a generated getter).
 - `system_reserve_gas()` returns `Ok(())` when present, that is, when `ethexe` is disabled.
 
 These behaviors are intentionally test-oriented and are not part of the `gcore` mapping defined above.

examples/demo/app/src/chaos/mod.rs

@@ -1,7 +1,8 @@
-use sails_rs::gstd::debug;
+use sails_rs::gstd::{Lock, debug};
 use sails_rs::{gstd, prelude::*};
 
 static mut REPLY_HOOK_COUNTER: u32 = 0;
+static mut CRITICAL_HOOK_COUNTER: u32 = 0;
 
 pub struct ChaosService;
 
@@ -10,9 +11,7 @@ impl ChaosService {
     #[export]
     pub async fn panic_after_wait(&self) {
         let source = Syscall::message_source();
-        let _ = gstd::msg::send_for_reply::<()>(source, (), 0, 0)
-            .unwrap()
-            .await;
+        let _ = gstd::send_for_reply::<()>(source, (), 0).unwrap().await;
         debug!("Message received, now panicking!");
         panic!("Simulated panic after wait");
     }
@@ -22,16 +21,19 @@ impl ChaosService {
         let source = Syscall::message_source();
         debug!("before handle_reply");
 
-        let fut = gstd::msg::send_for_reply::<()>(source, (), 0, 10_000_000_000).unwrap();
-        let fut = fut
-            .handle_reply(|| {
+        let fut = gstd::send_bytes_for_reply(
+            source,
+            &[],
+            0,
+            Lock::up_to(1),
+            None,
+            Some(10_000_000_000),
+            Some(Box::new(|| {
                 unsafe { REPLY_HOOK_COUNTER += 1 };
                 debug!("handle_reply triggered");
-            })
-            .unwrap()
-            .up_to(Some(1))
-            .unwrap();
-
+            })),
+        )
+        .unwrap();
         let _ = fut.await;
         debug!("after handle_reply");
     }
@@ -40,4 +42,56 @@ impl ChaosService {
     pub fn reply_hook_counter(&self) -> u32 {
         unsafe { REPLY_HOOK_COUNTER }
     }
+
+    /// Suspends the message for `blocks` blocks via `sleep_for`, then returns
+    /// the actual block delta. Used to verify the `MessageSleepFuture` lifecycle:
+    /// register sleep lock -> `exec::wait_for` -> resume at deadline -> complete.
+    #[export]
+    pub async fn sleep_then_return(&self, blocks: u32) -> u32 {
+        let start = Syscall::block_height();
+        gstd::sleep_for(blocks).await;
+        Syscall::block_height().saturating_sub(start)
+    }
+
+    /// Sends two messages for reply concurrently and resolves with the first to
+    /// reply via `futures::select`. Exercises `next_lock` picking the earliest
+    /// of several armed locks and `forget_future` reclaiming the losing branch
+    /// (its `MessageFuture` is dropped unresolved). Returns `0` if the first
+    /// send (`b"A"`) wins, `1` if the second (`b"B"`) does.
+    #[export]
+    pub async fn select_first_reply(&self) -> u8 {
+        use sails_rs::futures::future::{Either, select};
+
+        let source = Syscall::message_source();
+        let a = gstd::send_bytes_for_reply(source, b"A", 0, Lock::up_to(100), None, None, None)
+            .unwrap();
+        let b = gstd::send_bytes_for_reply(source, b"B", 0, Lock::up_to(100), None, None, None)
+            .unwrap();
+
+        match select(a, b).await {
+            Either::Left(_) => 0,
+            Either::Right(_) => 1,
+        }
+    }
+
+    /// Registers a critical hook, awaits a reply, then panics after resuming.
+    /// The trap on a message that reserved system gas makes the runtime invoke
+    /// `handle_signal`, which runs the stored critical hook. Used to verify the
+    /// `set_critical_hook` -> `handle_signal` path (distinct from the userspace
+    /// error reply). Observe the effect via [`Self::critical_hook_counter`].
+    #[export]
+    pub async fn critical_hook_on_signal(&self) {
+        gstd::set_critical_hook(|_msg_id| {
+            unsafe { CRITICAL_HOOK_COUNTER += 1 };
+            debug!("critical hook fired in handle_signal");
+        });
+        let source = Syscall::message_source();
+        let _ = gstd::send_for_reply::<()>(source, (), 0).unwrap().await;
+        panic!("panic after wait to trigger a signal");
+    }
+
+    #[export]
+    pub fn critical_hook_counter(&self) -> u32 {
+        unsafe { CRITICAL_HOOK_COUNTER }
+    }
 }

examples/demo/app/tests/gtest.rs

@@ -651,6 +651,147 @@ fn chaos_service_timeout_wait() {
     );
 }
 
+#[test]
+fn chaos_service_sleep_for_works() {
+    use demo_client::{chaos::io::SleepThenReturn, io::Default};
+    use sails_rs::gtest::{Program, System};
+
+    let system = System::new();
+    system.init_logger_with_default_filter("gwasm=debug,gtest=info,sails_rs=debug");
+    system.mint_to(ACTOR_ID, 1_000_000_000_000_000);
+    let program = Program::from_file(&system, DEMO_WASM_PATH);
+    program.send_bytes(ACTOR_ID, Default::encode_call(0));
+    system.run_next_block();
+
+    const SLEEP_BLOCKS: u32 = 3;
+    let msg_id = program.send_bytes(
+        ACTOR_ID,
+        SleepThenReturn::encode_call(DemoClientProgram::ROUTE_ID_CHAOS, SLEEP_BLOCKS),
+    );
+
+    // First block sends the message and suspends via sleep_for(SLEEP_BLOCKS),
+    // then the runtime must wake the task at the deadline. Scan a few blocks
+    // beyond the deadline; the reply lands in whichever block the wake occurs.
+    let mut reply_payload: Option<Vec<u8>> = None;
+    for _ in 0..(SLEEP_BLOCKS + 3) {
+        let run = system.run_next_block();
+        if let Some(payload) = run
+            .log()
+            .iter()
+            .find(|log| log.reply_to() == Some(msg_id))
+            .map(|log| log.payload().to_vec())
+        {
+            reply_payload = Some(payload);
+            break;
+        }
+    }
+    let payload = reply_payload.expect("sleep_then_return reply not produced");
+    let elapsed =
+        SleepThenReturn::decode_reply(DemoClientProgram::ROUTE_ID_CHAOS, payload).unwrap();
+    assert!(
+        elapsed >= SLEEP_BLOCKS,
+        "sleep_for should suspend at least {SLEEP_BLOCKS} blocks, got {elapsed}"
+    );
+}
+
+#[test]
+fn chaos_service_select_first_reply() {
+    use demo_client::{chaos::io::SelectFirstReply, io::Default};
+    use sails_rs::gtest::{Log, Program, System};
+
+    let system = System::new();
+    system.init_logger_with_default_filter("gwasm=debug,gtest=info,sails_rs=debug");
+    system.mint_to(ACTOR_ID, 1_000_000_000_000_000);
+    let program = Program::from_file(&system, DEMO_WASM_PATH);
+    program.send_bytes(ACTOR_ID, Default::encode_call(0));
+    system.run_next_block();
+
+    let msg_id = program.send_bytes(
+        ACTOR_ID,
+        SelectFirstReply::encode_call(DemoClientProgram::ROUTE_ID_CHAOS),
+    );
+    // First block: the method sends b"A" and b"B" concurrently, then suspends
+    // with two armed locks.
+    system.run_next_block();
+
+    // Reply only to the first send (b"A"); the second future is dropped
+    // unresolved when `select` resolves Left, exercising `forget_future`.
+    let log = Log::builder().source(program.id()).dest(ACTOR_ID);
+    system
+        .get_mailbox(ACTOR_ID)
+        .reply_bytes(log.payload_bytes(b"A"), vec![], 0)
+        .unwrap();
+    let run = system.run_next_block();
+
+    let payload = run
+        .log()
+        .iter()
+        .find(|log| log.reply_to() == Some(msg_id))
+        .map(|log| log.payload().to_vec())
+        .expect("select_first_reply did not produce a reply");
+    let winner =
+        SelectFirstReply::decode_reply(DemoClientProgram::ROUTE_ID_CHAOS, payload).unwrap();
+    assert_eq!(winner, 0, "the first send (b\"A\") must win the select");
+}
+
+#[test]
+fn chaos_service_critical_hook_on_signal() {
+    use demo_client::{
+        chaos::io::{CriticalHookCounter, CriticalHookOnSignal},
+        io::Default,
+    };
+    use sails_rs::gtest::{Log, Program, System};
+
+    let system = System::new();
+    system.init_logger_with_default_filter("gwasm=debug,gtest=info,sails_rs=debug");
+    system.mint_to(ACTOR_ID, 1_000_000_000_000_000);
+    let program = Program::from_file(&system, DEMO_WASM_PATH);
+    program.send_bytes(ACTOR_ID, Default::encode_call(0));
+    system.run_next_block();
+
+    let read_counter = |system: &System, program: &Program| {
+        let msg_id = program.send_bytes(
+            ACTOR_ID,
+            CriticalHookCounter::encode_call(DemoClientProgram::ROUTE_ID_CHAOS),
+        );
+        let run = system.run_next_block();
+        let payload = run
+            .log()
+            .iter()
+            .find(|log| log.reply_to() == Some(msg_id))
+            .map(|log| log.payload().to_vec())
+            .expect("counter reply not found");
+        CriticalHookCounter::decode_reply(DemoClientProgram::ROUTE_ID_CHAOS, payload).unwrap()
+    };
+
+    assert_eq!(read_counter(&system, &program), 0, "hook must not fire yet");
+
+    program.send_bytes(
+        ACTOR_ID,
+        CriticalHookOnSignal::encode_call(DemoClientProgram::ROUTE_ID_CHAOS),
+    );
+    // Sends the inner message (reserving system gas) and suspends.
+    system.run_next_block();
+
+    // Reply so the method resumes and panics; the trap on a message that
+    // reserved system gas drives the runtime into `handle_signal`, which runs
+    // the stored critical hook.
+    let log = Log::builder().source(program.id()).dest(ACTOR_ID);
+    system
+        .get_mailbox(ACTOR_ID)
+        .reply_bytes(log.payload_bytes(().encode()), vec![], 0)
+        .unwrap();
+    system.run_next_block();
+    // Signal processing may land in the following block.
+    system.run_next_block();
+
+    assert_eq!(
+        read_counter(&system, &program),
+        1,
+        "critical hook must fire exactly once via handle_signal"
+    );
+}
+
 #[tokio::test]
 async fn chaos_panic_does_not_affect_other_services() {
     use demo_client::chaos::Chaos as _;

examples/demo/client/demo_client.idl

@@ -148,12 +148,33 @@ service Validator@0x4e78bafffdb4fb1c {
     }
 }
 
-service Chaos@0xf0c8c80dfabf72d5 {
+service Chaos@0x6412b1f7e47f892d {
     functions {
+        @query
+        CriticalHookCounter() -> u32;
+        /// Registers a critical hook, awaits a reply, then panics after resuming.
+        /// The trap on a message that reserved system gas makes the runtime invoke
+        /// `handle_signal`, which runs the stored critical hook. Used to verify the
+        /// `set_critical_hook` -> `handle_signal` path (distinct from the userspace
+        /// error reply). Observe the effect via [`Self::critical_hook_counter`].
+        @query
+        CriticalHookOnSignal();
         @query
         PanicAfterWait();
         @query
         ReplyHookCounter() -> u32;
+        /// Sends two messages for reply concurrently and resolves with the first to
+        /// reply via `futures::select`. Exercises `next_lock` picking the earliest
+        /// of several armed locks and `forget_future` reclaiming the losing branch
+        /// (its `MessageFuture` is dropped unresolved). Returns `0` if the first
+        /// send (`b"A"`) wins, `1` if the second (`b"B"`) does.
+        @query
+        SelectFirstReply() -> u8;
+        /// Suspends the message for `blocks` blocks via `sleep_for`, then returns
+        /// the actual block delta. Used to verify the `MessageSleepFuture` lifecycle:
+        /// register sleep lock -> `exec::wait_for` -> resume at deadline -> complete.
+        @query
+        SleepThenReturn(blocks: u32) -> u32;
         @query
         TimeoutWait();
     }
@@ -198,7 +219,7 @@ program DemoClient {
         ThisThat@0x381e13fdd02d675f,
         ValueFee@0x61261a86528bf9d5,
         Validator@0x4e78bafffdb4fb1c,
-        Chaos@0xf0c8c80dfabf72d5,
+        Chaos@0x6412b1f7e47f892d,
         Chain@0x01fcbe183e2199b0,
         OverrideGenerics@0xa33febc87c18925b,
     }