Merge pull request #42 from alexcrichton/test-wasm

Run CI tests in wasm as well

Author: alexcrichton

.github/workflows/main.yml

@@ -18,11 +18,28 @@ jobs:
             rust: stable
           - os: windows-latest
             rust: stable
+          - os: ubuntu-latest
+            rust: stable
+            target: wasm32-wasip1
     steps:
     - uses: actions/checkout@v4
-    - name: Install Rust (
-      run: rustup update ${{ matrix.rust }} && rustup default ${{ matrix.rust }}
+    - run: rustup update ${{ matrix.rust }} --no-self-update && rustup default ${{ matrix.rust }}
       shell: bash
+
+    # Configure cross-builds by adding the rustup target and configuring future
+    # cargo invocations.
+    - run: |
+        rustup target add ${{ matrix.target }}
+        echo CARGO_BUILD_TARGET=${{ matrix.target }} >> $GITHUB_ENV
+      if: matrix.target != ''
+
+    # For wasm install wasmtime as a test runner and configure it with Cargo.
+    - name: Setup `wasmtime`
+      uses: bytecodealliance/actions/wasmtime/setup@v1
+      if: matrix.target == 'wasm32-wasip1'
+    - run: echo CARGO_TARGET_WASM32_WASIP1_RUNNER=wasmtime >> $GITHUB_ENV
+      if: matrix.target == 'wasm32-wasip1'
+
     - run: cargo test
     - run: cargo test --features debug
     - run: cargo test --features global

src/global.rs

@@ -1,6 +1,6 @@
 use crate::Dlmalloc;
 use core::alloc::{GlobalAlloc, Layout};
-use core::ops::{Deref, DerefMut};
+use core::ptr;
 
 pub use crate::sys::enable_alloc_after_fork;
 
@@ -10,52 +10,47 @@ pub use crate::sys::enable_alloc_after_fork;
 /// implements the `GlobalAlloc` trait in the standard library.
 pub struct GlobalDlmalloc;
 
+static mut DLMALLOC: Dlmalloc = Dlmalloc::new();
+
 unsafe impl GlobalAlloc for GlobalDlmalloc {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        <Dlmalloc>::malloc(&mut get(), layout.size(), layout.align())
+        let _guard = lock();
+        let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
+        (*dlmalloc).malloc(layout.size(), layout.align())
     }
 
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        <Dlmalloc>::free(&mut get(), ptr, layout.size(), layout.align())
+        let _guard = lock();
+        let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
+        (*dlmalloc).free(ptr, layout.size(), layout.align())
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        <Dlmalloc>::calloc(&mut get(), layout.size(), layout.align())
+        let _guard = lock();
+        let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
+        (*dlmalloc).calloc(layout.size(), layout.align())
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        <Dlmalloc>::realloc(&mut get(), ptr, layout.size(), layout.align(), new_size)
+        let _guard = lock();
+        let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
+        (*dlmalloc).realloc(ptr, layout.size(), layout.align(), new_size)
     }
 }
 
-static mut DLMALLOC: Dlmalloc = Dlmalloc::new();
-
-struct Instance;
-
-unsafe fn get() -> Instance {
+unsafe fn lock() -> impl Drop {
     crate::sys::acquire_global_lock();
-    Instance
-}
 
-impl Deref for Instance {
-    type Target = Dlmalloc;
-    fn deref(&self) -> &Dlmalloc {
-        unsafe { &DLMALLOC }
+    struct Guard;
+    impl Drop for Guard {
+        fn drop(&mut self) {
+            crate::sys::release_global_lock()
+        }
     }
-}
 
-impl DerefMut for Instance {
-    fn deref_mut(&mut self) -> &mut Dlmalloc {
-        unsafe { &mut DLMALLOC }
-    }
-}
-
-impl Drop for Instance {
-    fn drop(&mut self) {
-        crate::sys::release_global_lock()
-    }
+    Guard
 }

src/wasm.rs

@@ -68,6 +68,7 @@ pub fn release_global_lock() {
     assert!(!cfg!(target_feature = "atomics"));
 }
 
+#[allow(missing_docs)]
 #[cfg(feature = "global")]
 pub unsafe fn enable_alloc_after_fork() {
     // single threaded, no need!

tests/global.rs

@@ -26,6 +26,7 @@ fn strings() {
 }
 
 #[test]
+#[cfg(not(target_family = "wasm"))]
 fn threads() {
     assert!(thread::spawn(|| panic!()).join().is_err());
 }