Merge pull request #35 from alexcrichton/windows

Windows support: Rebase #26

Author: alexcrichton

.github/workflows/main.yml

@@ -4,21 +4,34 @@ on: [push, pull_request]
 jobs:
   test:
     name: Test
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        rust: [stable, beta, nightly]
+        include:
+          - os: ubuntu-latest
+            rust: stable
+          - os: ubuntu-latest
+            rust: beta
+          - os: ubuntu-latest
+            rust: nightly
+          - os: macos-latest
+            rust: stable
+          - os: windows-latest
+            rust: stable
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust (
       run: rustup update ${{ matrix.rust }} && rustup default ${{ matrix.rust }}
+      shell: bash
     - run: cargo test
     - run: cargo test --features debug
     - run: cargo test --features global
     - run: cargo test --release
     - run: cargo test --features debug --release
     - run: RUSTFLAGS='--cfg test_lots' cargo test --release
+      shell: bash
     - run: RUSTFLAGS='--cfg test_lots' cargo test --release --features debug
+      shell: bash
 
   rustfmt:
     name: Rustfmt

Cargo.toml

@@ -32,6 +32,16 @@ libc = { version = "0.2", default-features = false }
 # `src/tools/rustc-std-workspace` folder
 core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
 compiler_builtins = { version = '0.1.0', optional = true }
+cfg-if = "1.0"
+
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.52.0"
+features = [
+  "Win32_Foundation",
+  "Win32_System_Memory",
+  "Win32_System_Threading",
+  "Win32_System_SystemInformation",
+]
 
 [dev-dependencies]
 arbitrary = "1.3.2"

src/lib.rs

@@ -73,26 +73,24 @@ pub unsafe trait Allocator: Send {
 /// lingering memory back to the OS. That may happen eventually though!
 pub struct Dlmalloc<A = System>(dlmalloc::Dlmalloc<A>);
 
-#[cfg(target_family = "wasm")]
-#[path = "wasm.rs"]
-mod sys;
-
-#[cfg(any(target_os = "linux", target_os = "macos"))]
-#[path = "unix.rs"]
-mod sys;
-
-#[cfg(target_os = "xous")]
-#[path = "xous.rs"]
-mod sys;
-
-#[cfg(not(any(
-    target_os = "linux",
-    target_os = "macos",
-    target_os = "xous",
-    target_family = "wasm"
-)))]
-#[path = "dummy.rs"]
-mod sys;
+cfg_if::cfg_if! {
+    if #[cfg(target_family = "wasm")] {
+        #[path = "wasm.rs"]
+        mod sys;
+    } else if #[cfg(target_os = "windows")] {
+        #[path = "windows.rs"]
+        mod sys;
+    } else if #[cfg(target_os = "xous")] {
+        #[path = "xous.rs"]
+        mod sys;
+    } else if #[cfg(any(target_os = "linux", target_os = "macos"))] {
+        #[path = "unix.rs"]
+        mod sys;
+    } else {
+        #[path = "dummy.rs"]
+        mod sys;
+    }
+}
 
 impl Dlmalloc<System> {
     /// Creates a new instance of an allocator

src/unix.rs

@@ -1,5 +1,3 @@
-extern crate libc;
-
 use crate::Allocator;
 use core::ptr;
 

src/windows.rs

@@ -0,0 +1,88 @@
+use crate::Allocator;
+use core::mem::MaybeUninit;
+use core::ptr;
+use windows_sys::Win32::System::Memory::*;
+use windows_sys::Win32::System::SystemInformation::*;
+#[cfg(feature = "global")]
+use windows_sys::Win32::System::Threading::*;
+
+pub struct System {
+    _priv: (),
+}
+
+impl System {
+    pub const fn new() -> System {
+        System { _priv: () }
+    }
+}
+
+unsafe impl Allocator for System {
+    fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
+        let addr = unsafe {
+            VirtualAlloc(
+                ptr::null_mut(),
+                size,
+                MEM_RESERVE | MEM_COMMIT,
+                PAGE_READWRITE,
+            )
+        };
+
+        if addr.is_null() {
+            (ptr::null_mut(), 0, 0)
+        } else {
+            (addr.cast(), size, 0)
+        }
+    }
+
+    fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
+        ptr::null_mut()
+    }
+
+    fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool {
+        unsafe { VirtualFree(ptr.add(newsize).cast(), oldsize - newsize, MEM_DECOMMIT) != 0 }
+    }
+
+    fn free(&self, ptr: *mut u8, _size: usize) -> bool {
+        unsafe { VirtualFree(ptr.cast(), 0, MEM_DECOMMIT) != 0 }
+    }
+
+    fn can_release_part(&self, _flags: u32) -> bool {
+        true
+    }
+
+    fn allocates_zeros(&self) -> bool {
+        true
+    }
+
+    fn page_size(&self) -> usize {
+        unsafe {
+            let mut info = MaybeUninit::uninit();
+            GetSystemInfo(info.as_mut_ptr());
+            info.assume_init_ref().dwPageSize as usize
+        }
+    }
+}
+
+// NB: `SRWLOCK_INIT` doesn't appear to be in `windows-sys`
+#[cfg(feature = "global")]
+static mut LOCK: SRWLOCK = SRWLOCK {
+    Ptr: ptr::null_mut(),
+};
+
+#[cfg(feature = "global")]
+pub fn acquire_global_lock() {
+    unsafe {
+        AcquireSRWLockExclusive(ptr::addr_of_mut!(LOCK));
+    }
+}
+
+#[cfg(feature = "global")]
+pub fn release_global_lock() {
+    unsafe {
+        ReleaseSRWLockExclusive(ptr::addr_of_mut!(LOCK));
+    }
+}
+
+/// Not needed on Windows
+#[cfg(feature = "global")]
+pub unsafe fn enable_alloc_after_fork() {}