Introduce the sleep interface (#161)

* Introduce the `sleep` interface

* Fix example

Author: Spxg

crates/rsqlite-vfs/src/lib.rs

@@ -5,7 +5,6 @@
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
-#![cfg_attr(target_feature = "atomics", feature(stdarch_wasm_atomic_wait))]
 
 extern crate alloc;
 
@@ -25,6 +24,7 @@ use alloc::string::String;
 use alloc::vec::Vec;
 use alloc::{boxed::Box, ffi::CString};
 use alloc::{format, vec};
+use core::time::Duration;
 use core::{cell::RefCell, ffi::CStr, ops::Deref};
 
 pub mod memvfs;
@@ -464,6 +464,7 @@ pub trait SQLiteVfs<IO: SQLiteIoMethods> {
     const VERSION: ::core::ffi::c_int;
     const MAX_PATH_SIZE: ::core::ffi::c_int = 1024;
 
+    fn sleep(dur: Duration);
     fn random(buf: &mut [u8]);
     fn epoch_timestamp_in_ms() -> i64;
 
@@ -487,7 +488,7 @@ pub trait SQLiteVfs<IO: SQLiteIoMethods> {
             xDlSym: None,
             xDlClose: None,
             xRandomness: Some(Self::xRandomness),
-            xSleep: Some(x_methods_shim::xSleep),
+            xSleep: Some(Self::xSleep),
             xCurrentTime: Some(Self::xCurrentTime),
             xGetLastError: Some(Self::xGetLastError),
             xCurrentTimeInt64: Some(Self::xCurrentTimeInt64),
@@ -635,32 +636,45 @@ pub trait SQLiteVfs<IO: SQLiteIoMethods> {
 
     /// <https://github.com/sqlite/sqlite/blob/fb9e8e48fd70b463fb7ba6d99e00f2be54df749e/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js#L951>
     unsafe extern "C" fn xRandomness(
-        _pVfs: *mut sqlite3_vfs,
+        pVfs: *mut sqlite3_vfs,
         nByte: ::core::ffi::c_int,
         zOut: *mut ::core::ffi::c_char,
     ) -> ::core::ffi::c_int {
+        unused!(pVfs);
         let slice = core::slice::from_raw_parts_mut(zOut.cast(), nByte as usize);
         Self::random(slice);
         nByte
     }
 
     /// <https://github.com/sqlite/sqlite/blob/fb9e8e48fd70b463fb7ba6d99e00f2be54df749e/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js#L870>
     unsafe extern "C" fn xCurrentTime(
-        _pVfs: *mut sqlite3_vfs,
+        pVfs: *mut sqlite3_vfs,
         pTimeOut: *mut f64,
     ) -> ::core::ffi::c_int {
+        unused!(pVfs);
         *pTimeOut = 2440587.5 + (Self::epoch_timestamp_in_ms() as f64 / 86400000.0);
         SQLITE_OK
     }
 
     /// <https://github.com/sqlite/sqlite/blob/fb9e8e48fd70b463fb7ba6d99e00f2be54df749e/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js#L877>
     unsafe extern "C" fn xCurrentTimeInt64(
-        _pVfs: *mut sqlite3_vfs,
+        pVfs: *mut sqlite3_vfs,
         pOut: *mut sqlite3_int64,
     ) -> ::core::ffi::c_int {
+        unused!(pVfs);
         *pOut = ((2440587.5 * 86400000.0) + Self::epoch_timestamp_in_ms() as f64) as sqlite3_int64;
         SQLITE_OK
     }
+
+    unsafe extern "C" fn xSleep(
+        pVfs: *mut sqlite3_vfs,
+        microseconds: ::core::ffi::c_int,
+    ) -> ::core::ffi::c_int {
+        unused!(pVfs);
+        let dur = Duration::from_micros(microseconds as u64);
+        Self::sleep(dur);
+        SQLITE_OK
+    }
 }
 
 /// A trait that abstracts the `sqlite3_io_methods` struct, allowing for a more idiomatic Rust implementation.
@@ -865,45 +879,6 @@ pub trait SQLiteIoMethods {
     }
 }
 
-/// A module containing shims for VFS methods that are implemented using JavaScript interoperability.
-#[allow(clippy::missing_safety_doc)]
-pub mod x_methods_shim {
-    use super::*;
-
-    /// thread::sleep is available when atomics is enabled
-    #[cfg(target_feature = "atomics")]
-    pub unsafe extern "C" fn xSleep(
-        _pVfs: *mut sqlite3_vfs,
-        microseconds: ::core::ffi::c_int,
-    ) -> ::core::ffi::c_int {
-        use core::time::Duration;
-
-        // Use an atomic wait to block the current thread artificially with a
-        // timeout listed. Note that we should never be notified (return value
-        // of 0) or our comparison should never fail (return value of 1) so we
-        // should always only resume execution through a timeout (return value
-        // 2).
-        let dur = Duration::from_micros(microseconds as u64);
-        let mut nanos = dur.as_nanos();
-        while nanos > 0 {
-            let amt = core::cmp::min(i64::MAX as u128, nanos);
-            let mut x = 0;
-            let val = unsafe { core::arch::wasm32::memory_atomic_wait32(&mut x, 0, amt as i64) };
-            debug_assert_eq!(val, 2);
-            nanos -= amt;
-        }
-        SQLITE_OK
-    }
-
-    #[cfg(not(target_feature = "atomics"))]
-    pub unsafe extern "C" fn xSleep(
-        _pVfs: *mut sqlite3_vfs,
-        _microseconds: ::core::ffi::c_int,
-    ) -> ::core::ffi::c_int {
-        SQLITE_OK
-    }
-}
-
 #[derive(thiserror::Error, Debug)]
 pub enum ImportDbError {
     #[error("Byte array size is invalid for an SQLite db.")]

crates/rsqlite-vfs/src/memvfs.rs

@@ -43,6 +43,7 @@ use alloc::{format, vec};
 use core::cell::RefCell;
 use core::ffi::CStr;
 use core::marker::PhantomData;
+use core::time::Duration;
 use hashbrown::HashMap;
 
 const VFS_NAME: &CStr = c"memvfs";
@@ -99,6 +100,7 @@ impl VfsFile for MemFile {
 type MemAppData = RefCell<HashMap<String, MemFile>>;
 
 pub trait OsCallback {
+    fn sleep(dur: Duration);
     fn random(buf: &mut [u8]);
     fn epoch_timestamp_in_ms() -> i64;
 }
@@ -182,6 +184,10 @@ where
 {
     const VERSION: ::core::ffi::c_int = 1;
 
+    fn sleep(dur: Duration) {
+        C::sleep(dur);
+    }
+
     fn random(buf: &mut [u8]) {
         C::random(buf);
     }

crates/sqlite-wasm-vfs/src/relaxed_idb.rs

@@ -56,6 +56,7 @@ use sqlite_wasm_rs::{
     SQLITE_IOERR_DELETE, SQLITE_NOTFOUND, SQLITE_OK, SQLITE_OPEN_MAIN_DB,
 };
 use std::cell::RefCell;
+use std::time::Duration;
 
 use indexed_db_futures::database::Database;
 use indexed_db_futures::prelude::*;
@@ -721,6 +722,10 @@ struct RelaxedIdbVfs;
 impl SQLiteVfs<RelaxedIdbIoMethods> for RelaxedIdbVfs {
     const VERSION: ::std::os::raw::c_int = 1;
 
+    fn sleep(dur: Duration) {
+        WasmOsCallback::sleep(dur);
+    }
+
     fn random(buf: &mut [u8]) {
         WasmOsCallback::random(buf);
     }

crates/sqlite-wasm-vfs/src/sahpool.rs

@@ -45,6 +45,7 @@ use sqlite_wasm_rs::{
 };
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
+use std::time::Duration;
 
 use js_sys::{Array, DataView, IteratorNext, Reflect, Uint8Array};
 use wasm_bindgen::{JsCast, JsValue};
@@ -696,6 +697,10 @@ impl SQLiteVfs<SyncAccessHandleIoMethods> for SyncAccessHandleVfs {
         ret
     }
 
+    fn sleep(dur: Duration) {
+        WasmOsCallback::sleep(dur);
+    }
+
     fn random(buf: &mut [u8]) {
         WasmOsCallback::random(buf);
     }

examples/implement-a-vfs/src/lib.rs

@@ -10,6 +10,7 @@ use sqlite_wasm_rs::{
     },
     SQLITE_OK, SQLITE_OPEN_CREATE, SQLITE_OPEN_READWRITE,
 };
+use std::time::Duration;
 use std::{cell::RefCell, collections::HashMap};
 use wasm_bindgen_test::{console_log, wasm_bindgen_test};
 
@@ -182,6 +183,10 @@ struct MemVfs;
 impl SQLiteVfs<MemIoMethods> for MemVfs {
     const VERSION: ::std::os::raw::c_int = 1;
 
+    fn sleep(dur: Duration) {
+        sqlite_wasm_rs::WasmOsCallback::sleep(dur);
+    }
+
     fn random(buf: &mut [u8]) {
         sqlite_wasm_rs::WasmOsCallback::random(buf);
     }

src/lib.rs

@@ -17,9 +17,9 @@ pub mod utils {
     #[doc(inline)]
     pub use rsqlite_vfs::{
         bail, check_db_and_page_size, check_import_db, check_option, check_result, random_name,
-        register_vfs, registered_vfs, x_methods_shim, ImportDbError, MemChunksFile,
-        RegisterVfsError, SQLiteIoMethods, SQLiteVfs, SQLiteVfsFile, VfsAppData, VfsError, VfsFile,
-        VfsResult, VfsStore, SQLITE3_HEADER,
+        register_vfs, registered_vfs, ImportDbError, MemChunksFile, RegisterVfsError,
+        SQLiteIoMethods, SQLiteVfs, SQLiteVfsFile, VfsAppData, VfsError, VfsFile, VfsResult,
+        VfsStore, SQLITE3_HEADER,
     };
 
     #[doc(hidden)]